TB9.2 Example Applications: examples/PIPS/antiword/src/out2window.c Source File

00001 /*
-00002  * out2window.c
-00003  * Copyright (C) 1998-2005 A.J. van Os; Released under GPL
-00004  *
-00005  * Description:
-00006  * Output to a text window
-00007  */
-00008 
-00009 #include <string.h>
-00010 #include <stdlib.h>
-00011 #include <ctype.h>
-00012 #include "antiword.h"
-00013 
-00014 /* Used for numbering the chapters */
-00015 static unsigned int     auiHdrCounter[9];
-00016 
-00017 
-00018 /*
-00019  * vString2Diagram - put a string into a diagram
-00020  */
-00021 static void
-00022 vString2Diagram(diagram_type *pDiag, output_type *pAnchor)
-00023 {
-00024         output_type     *pOutput;
-00025         long            lWidth;
-00026         USHORT          usMaxFontSize;
-00027 
-00028         TRACE_MSG("vString2Diagram");
-00029 
-00030         fail(pDiag == NULL);
-00031         fail(pAnchor == NULL);
-00032 
-00033         /* Compute the maximum fontsize in this string */
-00034         usMaxFontSize = MIN_FONT_SIZE;
-00035         for (pOutput = pAnchor; pOutput != NULL; pOutput = pOutput->pNext) {
-00036                 if (pOutput->usFontSize > usMaxFontSize) {
-00037                         usMaxFontSize = pOutput->usFontSize;
-00038                 }
-00039         }
-00040 
-00041         /* Goto the next line */
-00042         vMove2NextLine(pDiag, pAnchor->tFontRef, usMaxFontSize);
-00043 
-00044         /* Output all substrings */
-00045         for (pOutput = pAnchor; pOutput != NULL; pOutput = pOutput->pNext) {
-00046                 lWidth = lMilliPoints2DrawUnits(pOutput->lStringWidth);
-00047                 vSubstring2Diagram(pDiag, pOutput->szStorage,
-00048                         pOutput->tNextFree, lWidth, pOutput->ucFontColor,
-00049                         pOutput->usFontStyle, pOutput->tFontRef,
-00050                         pOutput->usFontSize, usMaxFontSize);
-00051         }
-00052 
-00053         /* Goto the start of the line */
-00054         pDiag->lXleft = 0;
-00055         TRACE_MSG("leaving vString2Diagram");
-00056 } /* end of vString2Diagram */
-00057 
-00058 /*
-00059  * vSetLeftIndentation - set the left indentation of the specified diagram
-00060  */
-00061 void
-00062 vSetLeftIndentation(diagram_type *pDiag, long lLeftIndentation)
-00063 {
-00064         long    lX;
-00065 
-00066         TRACE_MSG("vSetLeftIndentation");
-00067 
-00068         fail(pDiag == NULL);
-00069         fail(lLeftIndentation < 0);
-00070 
-00071         lX = lMilliPoints2DrawUnits(lLeftIndentation);
-00072         if (lX > 0) {
-00073                 pDiag->lXleft = lX;
-00074         } else {
-00075                 pDiag->lXleft = 0;
-00076         }
-00077 } /* end of vSetLeftIndentation */
-00078 
-00079 /*
-00080  * lComputeNetWidth - compute the net string width
-00081  */
-00082 static long
-00083 lComputeNetWidth(output_type *pAnchor)
-00084 {
-00085         output_type     *pTmp;
-00086         long            lNetWidth;
-00087 
-00088         TRACE_MSG("lComputeNetWidth");
-00089 
-00090         fail(pAnchor == NULL);
-00091 
-00092         /* Step 1: Count all but the last sub-string */
-00093         lNetWidth = 0;
-00094         for (pTmp = pAnchor; pTmp->pNext != NULL; pTmp = pTmp->pNext) {
-00095                 fail(pTmp->lStringWidth < 0);
-00096                 lNetWidth += pTmp->lStringWidth;
-00097         }
-00098         fail(pTmp == NULL);
-00099         fail(pTmp->pNext != NULL);
-00100 
-00101         /* Step 2: remove the white-space from the end of the string */
-00102         while (pTmp->tNextFree != 0 &&
-00103                isspace((int)(UCHAR)pTmp->szStorage[pTmp->tNextFree - 1])) {
-00104                 pTmp->szStorage[pTmp->tNextFree - 1] = '\0';
-00105                 pTmp->tNextFree--;
-00106                 NO_DBG_DEC(pTmp->lStringWidth);
-00107                 pTmp->lStringWidth = lComputeStringWidth(
-00108                                                 pTmp->szStorage,
-00109                                                 pTmp->tNextFree,
-00110                                                 pTmp->tFontRef,
-00111                                                 pTmp->usFontSize);
-00112                 NO_DBG_DEC(pTmp->lStringWidth);
-00113         }
-00114 
-00115         /* Step 3: Count the last sub-string */
-00116         lNetWidth += pTmp->lStringWidth;
-00117         return lNetWidth;
-00118 } /* end of lComputeNetWidth */
-00119 
-00120 /*
-00121  * iComputeHoles - compute number of holes
-00122  * (A hole is a number of whitespace characters followed by a
-00123  *  non-whitespace character)
-00124  */
-00125 static int
-00126 iComputeHoles(output_type *pAnchor)
-00127 {
-00128         output_type     *pTmp;
-00129         size_t  tIndex;
-00130         int     iCounter;
-00131         BOOL    bWasSpace, bIsSpace;
-00132 
-00133         TRACE_MSG("iComputeHoles");
-00134 
-00135         fail(pAnchor == NULL);
-00136 
-00137         iCounter = 0;
-00138         bIsSpace = FALSE;
-00139         /* Count the holes */
-00140         for (pTmp = pAnchor; pTmp != NULL; pTmp = pTmp->pNext) {
-00141                 fail(pTmp->tNextFree != strlen(pTmp->szStorage));
-00142                 for (tIndex = 0; tIndex <= pTmp->tNextFree; tIndex++) {
-00143                         bWasSpace = bIsSpace;
-00144                         bIsSpace = isspace((int)(UCHAR)pTmp->szStorage[tIndex]);
-00145                         if (bWasSpace && !bIsSpace) {
-00146                                 iCounter++;
-00147                         }
-00148                 }
-00149         }
-00150         return iCounter;
-00151 } /* end of iComputeHoles */
-00152 
-00153 /*
-00154  * vAlign2Window - Align a string and insert it into the text
-00155  */
-00156 void
-00157 vAlign2Window(diagram_type *pDiag, output_type *pAnchor,
-00158         long lScreenWidth, UCHAR ucAlignment)
-00159 {
-00160         long    lNetWidth, lLeftIndentation;
-00161 
-00162         TRACE_MSG("vAlign2Window");
-00163 
-00164         fail(pDiag == NULL || pAnchor == NULL);
-00165         fail(lScreenWidth < lChar2MilliPoints(MIN_SCREEN_WIDTH));
-00166 
-00167         lNetWidth = lComputeNetWidth(pAnchor);
-00168 
-00169         if (lScreenWidth > lChar2MilliPoints(MAX_SCREEN_WIDTH) ||
-00170             lNetWidth <= 0) {
-00171                 /*
-00172                  * Screenwidth is "infinite", so no alignment is possible
-00173                  * Don't bother to align an empty line
-00174                  */
-00175                 vString2Diagram(pDiag, pAnchor);
-00176                 TRACE_MSG("leaving vAlign2Window #1");
-00177                 return;
-00178         }
-00179 
-00180         switch (ucAlignment) {
-00181         case ALIGNMENT_CENTER:
-00182                 lLeftIndentation = (lScreenWidth - lNetWidth) / 2;
-00183                 DBG_DEC_C(lLeftIndentation < 0, lLeftIndentation);
-00184                 if (lLeftIndentation > 0) {
-00185                         vSetLeftIndentation(pDiag, lLeftIndentation);
-00186                 }
-00187                 break;
-00188         case ALIGNMENT_RIGHT:
-00189                 lLeftIndentation = lScreenWidth - lNetWidth;
-00190                 DBG_DEC_C(lLeftIndentation < 0, lLeftIndentation);
-00191                 if (lLeftIndentation > 0) {
-00192                         vSetLeftIndentation(pDiag, lLeftIndentation);
-00193                 }
-00194                 break;
-00195         case ALIGNMENT_JUSTIFY:
-00196         case ALIGNMENT_LEFT:
-00197         default:
-00198                 break;
-00199         }
-00200         vString2Diagram(pDiag, pAnchor);
-00201         TRACE_MSG("leaving vAlign2Window #2");
-00202 } /* end of vAlign2Window */
-00203 
-00204 /*
-00205  * vJustify2Window - Justify a string and insert it into the text
-00206  */
-00207 void
-00208 vJustify2Window(diagram_type *pDiag, output_type *pAnchor,
-00209         long lScreenWidth, long lRightIndentation, UCHAR ucAlignment)
-00210 {
-00211         output_type     *pTmp;
-00212         char    *pcNew, *pcOld, *szStorage;
-00213         long    lNetWidth, lSpaceWidth, lToAdd;
-00214         int     iFillerLen, iHoles;
-00215 
-00216         TRACE_MSG("vJustify2Window");
-00217 
-00218         fail(pDiag == NULL || pAnchor == NULL);
-00219         fail(lScreenWidth < MIN_SCREEN_WIDTH);
-00220         fail(lRightIndentation > 0);
-00221 
-00222         if (ucAlignment != ALIGNMENT_JUSTIFY) {
-00223                 vAlign2Window(pDiag, pAnchor, lScreenWidth, ucAlignment);
-00224                 return;
-00225         }
-00226 
-00227         lNetWidth = lComputeNetWidth(pAnchor);
-00228 
-00229         if (lScreenWidth > lChar2MilliPoints(MAX_SCREEN_WIDTH) ||
-00230             lNetWidth <= 0) {
-00231                 /*
-00232                  * Screenwidth is "infinite", so justify is not possible
-00233                  * Don't bother to justify an empty line
-00234                  */
-00235                 vString2Diagram(pDiag, pAnchor);
-00236                 TRACE_MSG("leaving vJustify2Window #1");
-00237                 return;
-00238         }
-00239 
-00240         /* Justify */
-00241         fail(ucAlignment != ALIGNMENT_JUSTIFY);
-00242         lSpaceWidth = lComputeStringWidth(" ", 1,
-00243                                 pAnchor->tFontRef, pAnchor->usFontSize);
-00244         lToAdd = lScreenWidth -
-00245                         lNetWidth -
-00246                         lDrawUnits2MilliPoints(pDiag->lXleft) +
-00247                         lRightIndentation;
-00248 #if defined(DEBUG)
-00249         if (lToAdd / lSpaceWidth < -1) {
-00250                 DBG_DEC(lSpaceWidth);
-00251                 DBG_DEC(lToAdd);
-00252                 DBG_DEC(lScreenWidth);
-00253                 DBG_DEC(lNetWidth);
-00254                 DBG_DEC(lDrawUnits2MilliPoints(pDiag->lXleft));
-00255                 DBG_DEC(pDiag->lXleft);
-00256                 DBG_DEC(lRightIndentation);
-00257         }
-00258 #endif /* DEBUG */
-00259         lToAdd /= lSpaceWidth;
-00260         DBG_DEC_C(lToAdd < 0, lToAdd);
-00261         if (lToAdd <= 0) {
-00262                 vString2Diagram(pDiag, pAnchor);
-00263                 TRACE_MSG("leaving vJustify2Window #2");
-00264                 return;
-00265         }
-00266 
-00267         /* Justify by adding spaces */
-00268         iHoles = iComputeHoles(pAnchor);
-00269         for (pTmp = pAnchor; pTmp != NULL; pTmp = pTmp->pNext) {
-00270                 fail(pTmp->tNextFree != strlen(pTmp->szStorage));
-00271                 fail(lToAdd < 0);
-00272                 szStorage = xmalloc(pTmp->tNextFree + (size_t)lToAdd + 1);
-00273                 pcNew = szStorage;
-00274                 for (pcOld = pTmp->szStorage; *pcOld != '\0'; pcOld++) {
-00275                         *pcNew++ = *pcOld;
-00276                         if (*pcOld == ' ' &&
-00277                             *(pcOld + 1) != ' ' &&
-00278                             iHoles > 0) {
-00279                                 iFillerLen = (int)(lToAdd / iHoles);
-00280                                 lToAdd -= iFillerLen;
-00281                                 iHoles--;
-00282                                 for (; iFillerLen > 0; iFillerLen--) {
-00283                                         *pcNew++ = ' ';
-00284                                 }
-00285                         }
-00286                 }
-00287                 *pcNew = '\0';
-00288                 pTmp->szStorage = xfree(pTmp->szStorage);
-00289                 pTmp->szStorage = szStorage;
-00290                 pTmp->tStorageSize = pTmp->tNextFree + (size_t)lToAdd + 1;
-00291                 pTmp->lStringWidth +=
-00292                         (pcNew - szStorage - (long)pTmp->tNextFree) *
-00293                         lSpaceWidth;
-00294                 fail(pcNew < szStorage);
-00295                 pTmp->tNextFree = (size_t)(pcNew - szStorage);
-00296                 fail(pTmp->tNextFree != strlen(pTmp->szStorage));
-00297         }
-00298         DBG_DEC_C(lToAdd != 0, lToAdd);
-00299         vString2Diagram(pDiag, pAnchor);
-00300         TRACE_MSG("leaving vJustify2Window #3");
-00301 } /* end of vJustify2Window */
-00302 
-00303 /*
-00304  * vResetStyles - reset the style information variables
-00305  */
-00306 void
-00307 vResetStyles(void)
-00308 {
-00309         TRACE_MSG("vResetStyles");
-00310 
-00311         (void)memset(auiHdrCounter, 0, sizeof(auiHdrCounter));
-00312 } /* end of vResetStyles */
-00313 
-00314 /*
-00315  * tStyle2Window - Add the style characters to the line
-00316  *
-00317  * Returns the length of the resulting string
-00318  */
-00319 size_t
-00320 tStyle2Window(char *szLine, size_t tLineSize, const style_block_type *pStyle,
-00321         const section_block_type *pSection)
-00322 {
-00323         char    *pcTxt;
-00324         size_t  tIndex, tStyleIndex;
-00325         BOOL    bNeedPrevLvl;
-00326         level_type_enum eNumType;
-00327         UCHAR   ucNFC;
-00328 
-00329         TRACE_MSG("tStyle2Window");
-00330 
-00331         fail(szLine == NULL || pStyle == NULL || pSection == NULL);
-00332 
-00333         if (pStyle->usIstd == 0 || pStyle->usIstd > 9) {
-00334                 szLine[0] = '\0';
-00335                 return 0;
-00336         }
-00337 
-00338         /* Set the numbers */
-00339         tStyleIndex = (size_t)pStyle->usIstd - 1;
-00340         for (tIndex = 0; tIndex < 9; tIndex++) {
-00341                 if (tIndex == tStyleIndex) {
-00342                         auiHdrCounter[tIndex]++;
-00343                 } else if (tIndex > tStyleIndex) {
-00344                         auiHdrCounter[tIndex] = 0;
-00345                 } else if (auiHdrCounter[tIndex] == 0) {
-00346                         auiHdrCounter[tIndex] = 1;
-00347                 }
-00348         }
-00349 
-00350         eNumType = eGetNumType(pStyle->ucNumLevel);
-00351         if (eNumType != level_type_outline) {
-00352                 szLine[0] = '\0';
-00353                 return 0;
-00354         }
-00355 
-00356         /* Print the numbers */
-00357         pcTxt = szLine;
-00358         bNeedPrevLvl = (pSection->usNeedPrevLvl & BIT(tStyleIndex)) != 0;
-00359         for (tIndex = 0; tIndex <= tStyleIndex; tIndex++) {
-00360                 if (tIndex == tStyleIndex ||
-00361                     (bNeedPrevLvl && tIndex < tStyleIndex)) {
-00362                         if (pcTxt - szLine >= tLineSize - 25) {
-00363                                 /* Prevent a possible buffer overflow */
-00364                                 DBG_DEC(pcTxt - szLine);
-00365                                 DBG_DEC(tLineSize - 25);
-00366                                 DBG_FIXME();
-00367                                 szLine[0] = '\0';
-00368                                 return 0;
-00369                         }
-00370                         ucNFC = pSection->aucNFC[tIndex];
-00371                         switch(ucNFC) {
-00372                         case LIST_ARABIC_NUM:
-00373                         case LIST_NUMBER_TXT:
-00374                         case LIST_ORDINAL_TXT:
-00375                                 pcTxt += sprintf(pcTxt, "%u",
-00376                                         auiHdrCounter[tIndex]);
-00377                                 break;
-00378                         case LIST_UPPER_ROMAN:
-00379                         case LIST_LOWER_ROMAN:
-00380                                 pcTxt += tNumber2Roman(
-00381                                         auiHdrCounter[tIndex],
-00382                                         ucNFC == LIST_UPPER_ROMAN,
-00383                                         pcTxt);
-00384                                 break;
-00385                         case LIST_UPPER_ALPHA:
-00386                         case LIST_LOWER_ALPHA:
-00387                                 pcTxt += tNumber2Alpha(
-00388                                         auiHdrCounter[tIndex],
-00389                                         ucNFC == LIST_UPPER_ALPHA,
-00390                                         pcTxt);
-00391                                 break;
-00392                         case LIST_OUTLINE_NUM:
-00393                                 pcTxt += sprintf(pcTxt, "%02u",
-00394                                         auiHdrCounter[tIndex]);
-00395                                 break;
-00396                         default:
-00397                                 DBG_DEC(ucNFC);
-00398                                 DBG_FIXME();
-00399                                 pcTxt += sprintf(pcTxt, "%u",
-00400                                         auiHdrCounter[tIndex]);
-00401                                 break;
-00402                         }
-00403                         if (tIndex < tStyleIndex) {
-00404                                 *pcTxt++ = '.';
-00405                         } else if (tIndex == tStyleIndex) {
-00406                                 *pcTxt++ = ' ';
-00407                         }
-00408                 }
-00409         }
-00410         *pcTxt = '\0';
-00411         NO_DBG_MSG_C((int)pStyle->usIstd >= 1 &&
-00412                 (int)pStyle->usIstd <= 9 &&
-00413                 eNumType != level_type_none &&
-00414                 eNumType != level_type_outline, szLine);
-00415         NO_DBG_MSG_C(szLine[0] != '\0', szLine);
-00416         fail(pcTxt < szLine);
-00417         return (size_t)(pcTxt - szLine);
-00418 } /* end of tStyle2Window */
-00419 
-00420 /*
-00421  * vRemoveRowEnd - remove the end of table row indicator
-00422  *
-00423  * Remove the double TABLE_SEPARATOR characters from the end of the string.
-00424  * Special: remove the TABLE_SEPARATOR, 0x0a sequence
-00425  */
-00426 static void
-00427 vRemoveRowEnd(char *szRowTxt)
-00428 {
-00429         int     iLastIndex;
-00430 
-00431         TRACE_MSG("vRemoveRowEnd");
-00432 
-00433         fail(szRowTxt == NULL || szRowTxt[0] == '\0');
-00434 
-00435         iLastIndex = (int)strlen(szRowTxt) - 1;
-00436 
-00437         if (szRowTxt[iLastIndex] == TABLE_SEPARATOR ||
-00438             szRowTxt[iLastIndex] == (char)0x0a) {
-00439                 szRowTxt[iLastIndex] = '\0';
-00440                 iLastIndex--;
-00441         } else {
-00442                 DBG_HEX(szRowTxt[iLastIndex]);
-00443         }
-00444 
-00445         if (iLastIndex >= 0 && szRowTxt[iLastIndex] == (char)0x0a) {
-00446                 szRowTxt[iLastIndex] = '\0';
-00447                 iLastIndex--;
-00448         }
-00449 
-00450         if (iLastIndex >= 0 && szRowTxt[iLastIndex] == TABLE_SEPARATOR) {
-00451                 szRowTxt[iLastIndex] = '\0';
-00452                 return;
-00453         }
-00454 
-00455         DBG_DEC(iLastIndex);
-00456         DBG_HEX(szRowTxt[iLastIndex]);
-00457         DBG_MSG(szRowTxt);
-00458 } /* end of vRemoveRowEnd */
-00459 
-00460 /*
-00461  * tComputeStringLengthMax - max string length in relation to max column width
-00462  *
-00463  * Return the maximum string length
-00464  */
-00465 static size_t
-00466 tComputeStringLengthMax(const char *szString, size_t tColumnWidthMax)
-00467 {
-00468         const char      *pcTmp;
-00469         size_t  tLengthMax, tLenPrev, tLen, tWidth;
-00470 
-00471         TRACE_MSG("tComputeStringLengthMax");
-00472 
-00473         fail(szString == NULL);
-00474         fail(tColumnWidthMax == 0);
-00475 
-00476         pcTmp = strchr(szString, '\n');
-00477         if (pcTmp != NULL) {
-00478                 tLengthMax = (size_t)(pcTmp - szString + 1);
-00479         } else {
-00480                 tLengthMax = strlen(szString);
-00481         }
-00482         if (tLengthMax == 0) {
-00483                 return 0;
-00484         }
-00485 
-00486         tLen = 0;
-00487         tWidth = 0;
-00488         for (;;) {
-00489                 tLenPrev = tLen;
-00490                 tLen += tGetCharacterLength(szString + tLen);
-00491                 DBG_DEC_C(tLen > tLengthMax, tLen);
-00492                 DBG_DEC_C(tLen > tLengthMax, tLengthMax);
-00493                 fail(tLen > tLengthMax);
-00494                 tWidth = tCountColumns(szString, tLen);
-00495                 if (tWidth > tColumnWidthMax) {
-00496                         return tLenPrev;
-00497                 }
-00498                 if (tLen >= tLengthMax) {
-00499                         return tLengthMax;
-00500                 }
-00501         }
-00502 } /* end of tComputeStringLengthMax */
-00503 
-00504 /*
-00505  * tGetBreakingPoint - get the number of bytes that fit the column
-00506  *
-00507  * Returns the number of bytes that fit the column
-00508  */
-00509 static size_t
-00510 tGetBreakingPoint(const char *szString,
-00511         size_t tLen, size_t tWidth, size_t tColumnWidthMax)
-00512 {
-00513         int     iIndex;
-00514 
-00515         TRACE_MSG("tGetBreakingPoint");
-00516 
-00517         fail(szString == NULL);
-00518         fail(tLen > strlen(szString));
-00519         fail(tWidth > tColumnWidthMax);
-00520 
-00521         if (tWidth < tColumnWidthMax ||
-00522             (tWidth == tColumnWidthMax &&
-00523              (szString[tLen] == ' ' ||
-00524               szString[tLen] == '\n' ||
-00525               szString[tLen] == '\0'))) {
-00526                 /* The string already fits, do nothing */
-00527                 return tLen;
-00528         }
-00529         /* Search for a breaking point */
-00530         for (iIndex = (int)tLen - 1; iIndex >= 0; iIndex--) {
-00531                 if (szString[iIndex] == ' ') {
-00532                         return (size_t)iIndex;
-00533                 }
-00534         }
-00535         /* No breaking point found, just fill the column */
-00536         return tLen;
-00537 } /* end of tGetBreakingPoint */
-00538 
-00539 /*
-00540  * tComputeColumnWidthMax - compute the maximum column width
-00541  */
-00542 static size_t
-00543 tComputeColumnWidthMax(short sWidth, long lCharWidth, double dFactor)
-00544 {
-00545         size_t  tColumnWidthMax;
-00546 
-00547         TRACE_MSG("tComputeColumnWidthMax");
-00548 
-00549         fail(sWidth < 0);
-00550         fail(lCharWidth <= 0);
-00551         fail(dFactor <= 0.0);
-00552 
-00553         tColumnWidthMax = (size_t)(
-00554                 (lTwips2MilliPoints(sWidth) * dFactor + lCharWidth / 2.0) /
-00555                  lCharWidth);
-00556         if (tColumnWidthMax == 0) {
-00557                 /* Minimum column width */
-00558                 return 1;
-00559         }
-00560         if (tColumnWidthMax > 1) {
-00561                 /* Make room for the TABLE_SEPARATOR_CHAR */
-00562                 tColumnWidthMax--;
-00563         }
-00564         NO_DBG_DEC(tColumnWidthMax);
-00565         return tColumnWidthMax;
-00566 } /* end of tComputeColumnWidthMax */
-00567 
-00568 /*
-00569  * vTableRow2Window - put a table row into a diagram
-00570  */
-00571 void
-00572 vTableRow2Window(diagram_type *pDiag, output_type *pOutput,
-00573         const row_block_type *pRowInfo,
-00574         conversion_type eConversionType, int iParagraphBreak)
-00575 {
-00576         output_type     tRow;
-00577         char    *aszColTxt[TABLE_COLUMN_MAX];
-00578         char    *szLine, *pcTxt;
-00579         double  dMagnify;
-00580         long    lCharWidthLarge, lCharWidthSmall;
-00581         size_t  tColumnWidthTotal, atColumnWidthMax[TABLE_COLUMN_MAX];
-00582         size_t  tSize, tColumnWidthMax, tWidth, tLen;
-00583         int     iIndex, iNbrOfColumns, iTmp;
-00584         BOOL    bNotReady;
-00585 
-00586         TRACE_MSG("vTableRow2Window");
-00587 
-00588         fail(pDiag == NULL || pOutput == NULL || pRowInfo == NULL);
-00589         fail(pOutput->szStorage == NULL);
-00590         fail(pOutput->pNext != NULL);
-00591         fail(iParagraphBreak < 0);
-00592 
-00593         /* Character sizes */
-00594         lCharWidthLarge = lComputeStringWidth("W", 1,
-00595                                 pOutput->tFontRef, pOutput->usFontSize);
-00596         NO_DBG_DEC(lCharWidthLarge);
-00597         lCharWidthSmall = lComputeStringWidth("i", 1,
-00598                                 pOutput->tFontRef, pOutput->usFontSize);
-00599         NO_DBG_DEC(lCharWidthSmall);
-00600         /* For the time being: use a fixed width font */
-00601         fail(lCharWidthLarge != lCharWidthSmall);
-00602 
-00603         vRemoveRowEnd(pOutput->szStorage);
-00604 
-00605         /* Split the row text into a set of column texts */
-00606         aszColTxt[0] = pOutput->szStorage;
-00607         for (iNbrOfColumns = 1;
-00608              iNbrOfColumns < TABLE_COLUMN_MAX;
-00609              iNbrOfColumns++) {
-00610                 aszColTxt[iNbrOfColumns] =
-00611                                 strchr(aszColTxt[iNbrOfColumns - 1],
-00612                                         TABLE_SEPARATOR);
-00613                 if (aszColTxt[iNbrOfColumns] == NULL) {
-00614                         break;
-00615                 }
-00616                 *aszColTxt[iNbrOfColumns] = '\0';
-00617                 aszColTxt[iNbrOfColumns]++;
-00618                 NO_DBG_DEC(iNbrOfColumns);
-00619                 NO_DBG_MSG(aszColTxt[iNbrOfColumns]);
-00620         }
-00621 
-00622         /* Work around a bug in Word */
-00623         while (iNbrOfColumns > (int)pRowInfo->ucNumberOfColumns &&
-00624                pRowInfo->asColumnWidth[iNbrOfColumns] == 0) {
-00625                 iNbrOfColumns--;
-00626         }
-00627 
-00628         DBG_DEC_C(iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns,
-00629                 iNbrOfColumns);
-00630         DBG_DEC_C(iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns,
-00631                 pRowInfo->ucNumberOfColumns);
-00632         if (iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns) {
-00633                 werr(0, "Skipping an unmatched table row");
-00634                 return;
-00635         }
-00636 
-00637 #if defined(__FULL_TEXT_SEARCH)
-00638         /* No table formatting: use for full-text search (untested) */
-00639         for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
-00640                 fprintf(pDiag->pOutFile, "%s\n" , aszColTxt[iIndex]);
-00641         }
-00642 #else
-00643         if (bAddTableRow(pDiag, aszColTxt, iNbrOfColumns,
-00644                         pRowInfo->asColumnWidth, pRowInfo->ucBorderInfo)) {
-00645                 /* All work has been done */
-00646                 return;
-00647         }
-00648 
-00649         /* Fill the table with maximum column widths */
-00650         if (eConversionType == conversion_text ||
-00651             eConversionType == conversion_fmt_text) {
-00652                 if (iParagraphBreak == 0 ||
-00653                     iParagraphBreak >= MAX_SCREEN_WIDTH) {
-00654                         dMagnify = (double)MAX_SCREEN_WIDTH;
-00655                 } else if (iParagraphBreak <= MIN_SCREEN_WIDTH) {
-00656                         dMagnify = (double)MIN_SCREEN_WIDTH;
-00657                 } else {
-00658                         dMagnify = (double)iParagraphBreak;
-00659                 }
-00660                 dMagnify /= (double)DEFAULT_SCREEN_WIDTH;
-00661                 DBG_FLT_C(dMagnify < 0.99 || dMagnify > 1.01, dMagnify);
-00662         } else {
-00663                 dMagnify = 1.0;
-00664         }
-00665         tColumnWidthTotal = 0;
-00666         for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
-00667                 atColumnWidthMax[iIndex] = tComputeColumnWidthMax(
-00668                                         pRowInfo->asColumnWidth[iIndex],
-00669                                         lCharWidthLarge,
-00670                                         dMagnify);
-00671                 tColumnWidthTotal += atColumnWidthMax[iIndex];
-00672         }
-00673 
-00674         /*
-00675          * Get enough space for the row.
-00676          * Worst case: three bytes per UTF-8 character
-00677          */
-00678         tSize = 3 * (1 + tColumnWidthTotal + (size_t)iNbrOfColumns + 3);
-00679         szLine = xmalloc(tSize);
-00680 
-00681         do {
-00682                 /* Print one line of a table row */
-00683                 bNotReady = FALSE;
-00684                 pcTxt = szLine;
-00685                 *pcTxt++ = TABLE_SEPARATOR_CHAR;
-00686                 for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
-00687                         tColumnWidthMax = atColumnWidthMax[iIndex];
-00688                         if (aszColTxt[iIndex] == NULL) {
-00689                                 /* Add an empty column */
-00690                                 for (iTmp = 0;
-00691                                      iTmp < (int)tColumnWidthMax;
-00692                                      iTmp++) {
-00693                                         *pcTxt++ = (char)FILLER_CHAR;
-00694                                 }
-00695                                 *pcTxt++ = TABLE_SEPARATOR_CHAR;
-00696                                 *pcTxt = '\0';
-00697                                 continue;
-00698                         }
-00699                         /* Compute the length and width of the column text */
-00700                         tLen = tComputeStringLengthMax(
-00701                                         aszColTxt[iIndex], tColumnWidthMax);
-00702                         NO_DBG_DEC(tLen);
-00703                         while (tLen != 0 &&
-00704                                         (aszColTxt[iIndex][tLen - 1] == '\n' ||
-00705                                          aszColTxt[iIndex][tLen - 1] == ' ')) {
-00706                                 aszColTxt[iIndex][tLen - 1] = ' ';
-00707                                 tLen--;
-00708                         }
-00709                         tWidth = tCountColumns(aszColTxt[iIndex], tLen);
-00710                         fail(tWidth > tColumnWidthMax);
-00711                         tLen = tGetBreakingPoint(aszColTxt[iIndex],
-00712                                         tLen, tWidth, tColumnWidthMax);
-00713                         tWidth = tCountColumns(aszColTxt[iIndex], tLen);
-00714                         if (tLen == 0 && *aszColTxt[iIndex] == '\0') {
-00715                                 /* No text at all */
-00716                                 aszColTxt[iIndex] = NULL;
-00717                         } else {
-00718                                 /* Add the text */
-00719                                 pcTxt += sprintf(pcTxt,
-00720                                         "%.*s", (int)tLen, aszColTxt[iIndex]);
-00721                                 if (tLen == 0 && *aszColTxt[iIndex] != ' ') {
-00722                                         tLen = tGetCharacterLength(
-00723                                                         aszColTxt[iIndex]);
-00724                                         DBG_CHR(*aszColTxt[iIndex]);
-00725                                         DBG_FIXME();
-00726                                         fail(tLen == 0);
-00727                                 }
-00728                                 aszColTxt[iIndex] += tLen;
-00729                                 while (*aszColTxt[iIndex] == ' ') {
-00730                                         aszColTxt[iIndex]++;
-00731                                 }
-00732                                 if (*aszColTxt[iIndex] == '\0') {
-00733                                         /* This row is now complete */
-00734                                         aszColTxt[iIndex] = NULL;
-00735                                 } else {
-00736                                         /* This row needs more lines */
-00737                                         bNotReady = TRUE;
-00738                                 }
-00739                         }
-00740                         /* Fill up the rest */
-00741                         for (iTmp = 0;
-00742                              iTmp < (int)tColumnWidthMax - (int)tWidth;
-00743                              iTmp++) {
-00744                                 *pcTxt++ = (char)FILLER_CHAR;
-00745                         }
-00746                         /* End of column */
-00747                         *pcTxt++ = TABLE_SEPARATOR_CHAR;
-00748                         *pcTxt = '\0';
-00749                 }
-00750                 /* Output the table row line */
-00751                 *pcTxt = '\0';
-00752                 tRow = *pOutput;
-00753                 tRow.szStorage = szLine;
-00754                 fail(pcTxt < szLine);
-00755                 tRow.tNextFree = (size_t)(pcTxt - szLine);
-00756                 tRow.lStringWidth = lComputeStringWidth(
-00757                                         tRow.szStorage,
-00758                                         tRow.tNextFree,
-00759                                         tRow.tFontRef,
-00760                                         tRow.usFontSize);
-00761                 vString2Diagram(pDiag, &tRow);
-00762                 TRACE_MSG("after vString2Diagram in vTableRow2Window");
-00763         } while (bNotReady);
-00764         /* Clean up before you leave */
-00765         szLine = xfree(szLine);
-00766         TRACE_MSG("leaving vTableRow2Window");
-00767 #endif /* __FULL_TEXT_SEARCH */
-00768 } /* end of vTableRow2Window */
-