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