Ignore:
Timestamp:
Aug 27, 2010, 11:00:52 AM (11 years ago)
Author:
Silvan Scherrer
Message:

poppler update to 0.14.2

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/TextOutputDev.cc

    r367 r461  
    1818// Copyright (C) 2007, 2008 Adrian Johnson <ajohnson@redneon.com>
    1919// Copyright (C) 2008 Koji Otani <sho@bbr.jp>
    20 // Copyright (C) 2008 Albert Astals Cid <aacid@kde.org>
     20// Copyright (C) 2008, 2010 Albert Astals Cid <aacid@kde.org>
    2121// Copyright (C) 2008 Pino Toscano <pino@kde.org>
    22 // Copyright (C) 2008 Hib Eris <hib@hiberis.nl>
     22// Copyright (C) 2008, 2010 Hib Eris <hib@hiberis.nl>
    2323// Copyright (C) 2009 Ross Moore <ross@maths.mq.edu.au>
    2424// Copyright (C) 2009 Kovid Goyal <kovid@kovidgoyal.net>
     25// Copyright (C) 2010 Brian Ewins <brian.ewins@gmail.com>
    2526//
    2627// To see a description of the changes please see the Changelog file that
     
    3940#include <stddef.h>
    4041#include <math.h>
     42#include <float.h>
    4143#include <ctype.h>
    4244#ifdef _WIN32
     
    11551157  next = NULL;
    11561158  stackNext = NULL;
     1159  tableId = -1;
     1160  tableEnd = gFalse;
    11571161}
    11581162
     
    16231627  case 0:
    16241628  case 2:
    1625     overlap = ((this->xMin <= blk1->xMin) &&
    1626                (blk1->xMin <= this->xMax)) ||
    1627       ((blk1->xMin <= this->xMin) &&
    1628        (this->xMin <= blk1->xMax));
     1629    overlap = ((this->ExMin <= blk1->ExMin) &&
     1630               (blk1->ExMin <= this->ExMax)) ||
     1631      ((blk1->ExMin <= this->ExMin) &&
     1632       (this->ExMin <= blk1->ExMax));
    16291633    break;
    16301634  case 1:
    16311635  case 3:
    1632     overlap = ((this->yMin <= blk1->yMin) &&
    1633                (blk1->yMin <= this->yMax)) ||
    1634       ((blk1->yMin <= this->yMin) &&
    1635        (this->yMin <= blk1->yMax));
     1636    overlap = ((this->EyMin <= blk1->EyMin) &&
     1637               (blk1->EyMin <= this->EyMax)) ||
     1638      ((blk1->EyMin <= this->EyMin) &&
     1639       (this->EyMin <= blk1->EyMax));
    16361640    break;
    16371641  }
    16381642  switch (this->page->primaryRot) {
    16391643  case 0:
    1640     before = overlap && this->yMin < blk1->yMin;
     1644    before = overlap && this->EyMin < blk1->EyMin;
    16411645    break;
    16421646  case 1:
    1643     before = overlap && this->xMax > blk1->xMax;
     1647    before = overlap && this->ExMax > blk1->ExMax;
    16441648    break;
    16451649  case 2:
    1646     before = overlap && this->yMax > blk1->yMax;
     1650    before = overlap && this->EyMax > blk1->EyMax;
    16471651    break;
    16481652  case 3:
    1649     before = overlap && this->xMin < blk1->xMin;
     1653    before = overlap && this->ExMin < blk1->ExMin;
    16501654    break;
    16511655  }
     
    16631667  switch (rotLR) {
    16641668  case 0:
    1665     cmp = xMax - blk1->xMin;
     1669    cmp = ExMax - blk1->ExMin;
    16661670    break;
    16671671  case 1:
    1668     cmp = yMin - blk1->yMax;
     1672    cmp = EyMin - blk1->EyMax;
    16691673    break;
    16701674  case 2:
    1671     cmp = blk1->xMax - xMin;
     1675    cmp = blk1->ExMax - ExMin;
    16721676    break;
    16731677  case 3:
    1674     cmp = blk1->yMin - yMax;
     1678    cmp = blk1->EyMin - EyMax;
    16751679    break;
    16761680  }
     
    16981702#if 0 // for debugging
    16991703  printf("visited: %d %.2f..%.2f %.2f..%.2f\n",
    1700          sortPos, blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
     1704         sortPos, blk1->ExMin, blk1->ExMax, blk1->EyMin, blk1->EyMax);
    17011705#endif
    17021706  visited[pos1] = gTrue;
     
    17091713    }
    17101714    before = gFalse;
    1711     if (blk2->isBeforeByRule1(blk1)) {
    1712       // Rule (1) blk1 and blk2 overlap, and blk2 is above blk1.
    1713       before = gTrue;
     1715
     1716    // is blk2 before blk1? (for table entries)
     1717    if (blk1->tableId >= 0 && blk1->tableId == blk2->tableId) {
     1718      if (page->primaryLR) {
     1719        if (blk2->xMax <= blk1->xMin &&
     1720            blk2->yMin <= blk1->yMax &&
     1721            blk2->yMax >= blk1->yMin)
     1722          before = gTrue;
     1723      } else {
     1724        if (blk2->xMin >= blk1->xMax &&
     1725            blk2->yMin <= blk1->yMax &&
     1726            blk2->yMax >= blk1->yMin)
     1727          before = gTrue;
     1728      }
     1729
     1730      if (blk2->yMax <= blk1->yMin)
     1731        before = gTrue;
     1732    } else {
     1733      if (blk2->isBeforeByRule1(blk1)) {
     1734        // Rule (1) blk1 and blk2 overlap, and blk2 is above blk1.
     1735        before = gTrue;
     1736#if 0   // for debugging
     1737        printf("rule1: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
     1738               blk2->ExMin, blk2->ExMax, blk2->EyMin, blk2->EyMax,
     1739               blk1->ExMin, blk1->ExMax, blk1->EyMin, blk1->EyMax);
     1740#endif
     1741      } else if (blk2->isBeforeByRule2(blk1)) {
     1742        // Rule (2) blk2 left of blk1, and no intervening blk3
     1743        //          such that blk1 is before blk3 by rule 1,
     1744        //          and blk3 is before blk2 by rule 1.
     1745        before = gTrue;
     1746        for (blk3 = blkList; blk3; blk3 = blk3->next) {
     1747          if (blk3 == blk2 || blk3 == blk1) {
     1748            continue;
     1749          }
     1750          if (blk1->isBeforeByRule1(blk3) &&
     1751              blk3->isBeforeByRule1(blk2)) {
     1752            before = gFalse;
     1753            break;
     1754          }
     1755        }
    17141756#if 0 // for debugging
    1715       printf("rule1: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
    1716              blk2->xMin, blk2->xMax, blk2->yMin, blk2->yMax,
    1717              blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
     1757        if (before) {
     1758          printf("rule2: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
     1759                 blk1->ExMin, blk1->ExMax, blk1->EyMin, blk1->EyMax,
     1760                 blk2->ExMin, blk2->ExMax, blk2->EyMin, blk2->EyMax);
     1761        }
    17181762#endif
    1719     } else if (blk2->isBeforeByRule2(blk1)) {
    1720       // Rule (2) blk2 left of blk1, and no intervening blk3
    1721       //          such that blk1 is before blk3 by rule 1,
    1722       //          and blk3 is before blk2 by rule 1.
    1723       before = gTrue;
    1724       for (blk3 = blkList; blk3; blk3 = blk3->next) {
    1725         if (blk3 == blk2 || blk3 == blk1) {
    1726           continue;
    1727         }
    1728         if (blk1->isBeforeByRule1(blk3) &&
    1729             blk3->isBeforeByRule1(blk2)) {
    1730           before = gFalse;
    1731           break;
    1732         }
    1733       }
    1734 #if 0 // for debugging
    1735       if (before) {
    1736         printf("rule2: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
    1737                blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax,
    1738                blk2->xMin, blk2->xMax, blk2->yMin, blk2->yMax);
    1739       }
    1740 #endif
     1763      }
    17411764    }
    17421765    if (before) {
     
    17481771#if 0 // for debugging
    17491772  printf("sorted: %d %.2f..%.2f %.2f..%.2f\n",
    1750          sortPos, blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
     1773         sortPos, blk1->ExMin, blk1->ExMax, blk1->EyMin, blk1->EyMax);
    17511774#endif
    17521775  sorted[sortPos++] = blk1;
     
    22292252    }
    22302253
    2231   // page rotation and/or transform matrices can cause text to be
    2232   // drawn in reverse order -- in this case, swap the begin/end
    2233   // coordinates and break text into individual chars
    2234   if ((curWord->rot == 0 && w1 < 0) ||
    2235       (curWord->rot == 1 && h1 < 0) ||
    2236       (curWord->rot == 2 && w1 > 0) ||
    2237       (curWord->rot == 3 && h1 > 0)) {
    2238     endWord();
    2239     beginWord(state, x + dx, y + dy);
    2240     x1 += w1;
    2241     y1 += h1;
    2242     w1 = -w1;
    2243     h1 = -h1;
    2244   }
    2245 
    2246   // add the characters to the current word
     2254    // page rotation and/or transform matrices can cause text to be
     2255    // drawn in reverse order -- in this case, swap the begin/end
     2256    // coordinates and break text into individual chars
     2257    if ((curWord->rot == 0 && w1 < 0) ||
     2258        (curWord->rot == 1 && h1 < 0) ||
     2259        (curWord->rot == 2 && w1 > 0) ||
     2260        (curWord->rot == 3 && h1 > 0)) {
     2261      endWord();
     2262      beginWord(state, x + dx, y + dy);
     2263      x1 += w1;
     2264      y1 += h1;
     2265      w1 = -w1;
     2266      h1 = -h1;
     2267    }
     2268
     2269    // add the characters to the current word
    22472270    w1 /= uLen;
    22482271    h1 /= uLen;
    2249   for (i = 0; i < uLen; ++i) {
     2272    for (i = 0; i < uLen; ++i) {
    22502273      if (u[i] >= 0xd800 && u[i] < 0xdc00) { /* surrogate pair */
    22512274        if (i + 1 < uLen && u[i+1] >= 0xdc00 && u[i+1] < 0xe000) {
     
    22662289        curWord->addChar(state, x1 + i*w1, y1 + i*h1, w1, h1, c, u[i]);
    22672290      }
    2268   }
     2291    }
    22692292  }
    22702293  if (curWord) {
     
    23222345  TextWord *word0, *word1, *word2;
    23232346  TextLine *line;
    2324   TextBlock *blkList, *blk, *lastBlk, *blk0, *blk1;
     2347  TextBlock *blkList, *blk, *lastBlk, *blk0, *blk1, *blk2;
    23252348  TextFlow *flow, *lastFlow;
    23262349  TextUnderline *underline;
     
    29983021    visited[i] = gFalse;
    29993022  }
     3023
     3024  double bxMin0, byMin0, bxMin1, byMin1;
     3025  int numTables = 0;
     3026  int tableId = -1;
     3027  int correspondenceX, correspondenceY;
     3028  double xCentre1, yCentre1, xCentre2, yCentre2;
     3029  double xCentre3, yCentre3, xCentre4, yCentre4;
     3030  double deltaX, deltaY;
     3031  TextBlock *fblk2 = NULL, *fblk3 = NULL, *fblk4 = NULL;
     3032
     3033  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     3034    blk1->ExMin = blk1->xMin;
     3035    blk1->ExMax = blk1->xMax;
     3036    blk1->EyMin = blk1->yMin;
     3037    blk1->EyMax = blk1->yMax;
     3038
     3039    bxMin0 = DBL_MAX;
     3040    byMin0 = DBL_MAX;
     3041    bxMin1 = DBL_MAX;
     3042    byMin1 = DBL_MAX;
     3043
     3044    fblk2 = NULL;
     3045    fblk3 = NULL;
     3046    fblk4 = NULL;
     3047
     3048    /*  find fblk2, fblk3 and fblk4 so that
     3049     *  fblk2 is on the right of blk1 and overlap with blk1 in y axis
     3050     *  fblk3 is under blk1 and overlap with blk1 in x axis
     3051     *  fblk4 is under blk1 and on the right of blk1
     3052     *  and they are closest to blk1
     3053     */
     3054    for (blk2 = blkList; blk2; blk2 = blk2->next) {
     3055      if (blk2 != blk1) {
     3056        if (blk2->yMin <= blk1->yMax &&
     3057            blk2->yMax >= blk1->yMin &&
     3058            blk2->xMin > blk1->xMax &&
     3059            blk2->xMin < bxMin0) {
     3060          bxMin0 = blk2->xMin;
     3061          fblk2 = blk2;
     3062        } else if (blk2->xMin <= blk1->xMax &&
     3063                   blk2->xMax >= blk1->xMin &&
     3064                   blk2->yMin > blk1->yMax &&
     3065                   blk2->yMin < byMin0) {
     3066          byMin0 = blk2->yMin;
     3067          fblk3 = blk2;
     3068        } else if (blk2->xMin > blk1->xMax &&
     3069                   blk2->xMin < bxMin1 &&
     3070                   blk2->yMin > blk1->yMax &&
     3071                   blk2->yMin < byMin1) {
     3072          bxMin1 = blk2->xMin;
     3073          byMin1 = blk2->yMin;
     3074          fblk4 = blk2;
     3075        }
     3076      }
     3077    }
     3078
     3079    /*  fblk4 can not overlap with fblk3 in x and with fblk2 in y
     3080     *  fblk2 can not overlap with fblk3 in x and y
     3081     *  fblk4 has to overlap with fblk3 in y and with fblk2 in x
     3082     */
     3083    if (fblk2 != NULL &&
     3084        fblk3 != NULL &&
     3085        fblk4 != NULL) {
     3086      if (((fblk3->xMin <= fblk4->xMax && fblk3->xMax >= fblk4->xMin) ||
     3087           (fblk2->yMin <= fblk4->yMax && fblk2->yMax >= fblk4->yMin) ||
     3088           (fblk2->xMin <= fblk3->xMax && fblk2->xMax >= fblk3->xMin) ||
     3089           (fblk2->yMin <= fblk3->yMax && fblk2->yMax >= fblk3->yMin)) ||
     3090          !(fblk4->xMin <= fblk2->xMax && fblk4->xMax >= fblk2->xMin &&
     3091            fblk4->yMin <= fblk3->yMax && fblk4->yMax >= fblk3->yMin)) {
     3092        fblk2 = NULL;
     3093        fblk3 = NULL;
     3094        fblk4 = NULL;
     3095      }
     3096    }
     3097
     3098    // if we found any then look whether they form a table
     3099    if (fblk2 != NULL &&
     3100        fblk3 != NULL &&
     3101        fblk4 != NULL) {
     3102      tableId = -1;
     3103      correspondenceX = 0;
     3104      correspondenceY = 0;
     3105      deltaX = 0.0;
     3106      deltaY = 0.0;
     3107
     3108      if (blk1->lines && blk1->lines->words)
     3109        deltaX = blk1->lines->words->getFontSize();
     3110      if (fblk2->lines && fblk2->lines->words)
     3111        deltaX = deltaX < fblk2->lines->words->getFontSize() ?
     3112                   deltaX : fblk2->lines->words->getFontSize();
     3113      if (fblk3->lines && fblk3->lines->words)
     3114        deltaX = deltaX < fblk3->lines->words->getFontSize() ?
     3115                   deltaX : fblk3->lines->words->getFontSize();
     3116      if (fblk4->lines && fblk4->lines->words)
     3117        deltaX = deltaX < fblk4->lines->words->getFontSize() ?
     3118                   deltaX : fblk4->lines->words->getFontSize();
     3119
     3120      deltaY = deltaX;
     3121
     3122      deltaX *= minColSpacing1;
     3123      deltaY *= maxIntraLineDelta;
     3124
     3125      xCentre1 = (blk1->xMax + blk1->xMin) / 2.0;
     3126      yCentre1 = (blk1->yMax + blk1->yMin) / 2.0;
     3127      xCentre2 = (fblk2->xMax + fblk2->xMin) / 2.0;
     3128      yCentre2 = (fblk2->yMax + fblk2->yMin) / 2.0;
     3129      xCentre3 = (fblk3->xMax + fblk3->xMin) / 2.0;
     3130      yCentre3 = (fblk3->yMax + fblk3->yMin) / 2.0;
     3131      xCentre4 = (fblk4->xMax + fblk4->xMin) / 2.0;
     3132      yCentre4 = (fblk4->yMax + fblk4->yMin) / 2.0;
     3133
     3134      // are blocks centrally aligned in x ?
     3135      if (fabs (xCentre1 - xCentre3) <= deltaX &&
     3136          fabs (xCentre2 - xCentre4) <= deltaX)
     3137        correspondenceX++;
     3138
     3139      // are blocks centrally aligned in y ?
     3140      if (fabs (yCentre1 - yCentre2) <= deltaY &&
     3141          fabs (yCentre3 - yCentre4) <= deltaY)
     3142        correspondenceY++;
     3143
     3144      // are blocks aligned to the left ?
     3145      if (fabs (blk1->xMin - fblk3->xMin) <= deltaX &&
     3146          fabs (fblk2->xMin - fblk4->xMin) <= deltaX)
     3147        correspondenceX++;
     3148
     3149      // are blocks aligned to the right ?
     3150      if (fabs (blk1->xMax - fblk3->xMax) <= deltaX &&
     3151          fabs (fblk2->xMax - fblk4->xMax) <= deltaX)
     3152        correspondenceX++;
     3153
     3154      // are blocks aligned to the top ?
     3155      if (fabs (blk1->yMin - fblk2->yMin) <= deltaY &&
     3156          fabs (fblk3->yMin - fblk4->yMin) <= deltaY)
     3157        correspondenceY++;
     3158
     3159      // are blocks aligned to the bottom ?
     3160      if (fabs (blk1->yMax - fblk2->yMax) <= deltaY &&
     3161          fabs (fblk3->yMax - fblk4->yMax) <= deltaY)
     3162        correspondenceY++;
     3163
     3164      // are blocks aligned in x and y ?
     3165      if (correspondenceX > 0 &&
     3166          correspondenceY > 0) {
     3167
     3168        // find maximal tableId
     3169        tableId = tableId < fblk4->tableId ? fblk4->tableId : tableId;
     3170        tableId = tableId < fblk3->tableId ? fblk3->tableId : tableId;
     3171        tableId = tableId < fblk2->tableId ? fblk2->tableId : tableId;
     3172        tableId = tableId < blk1->tableId ? blk1->tableId : tableId;
     3173
     3174        // if the tableId is -1, then we found new table
     3175        if (tableId < 0) {
     3176          tableId = numTables;
     3177          numTables++;
     3178        }
     3179
     3180        blk1->tableId = tableId;
     3181        fblk2->tableId = tableId;
     3182        fblk3->tableId = tableId;
     3183        fblk4->tableId = tableId;
     3184      }
     3185    }
     3186  }
     3187
     3188  /*  set extended bounding boxes of all table entries
     3189   *  so that they contain whole table
     3190   *  (we need to process whole table size when comparing it
     3191   *   with regular text blocks)
     3192   */
     3193  PDFRectangle *envelopes = new PDFRectangle [numTables];
     3194  TextBlock **ending_blocks = new TextBlock* [numTables];
     3195
     3196  for (i = 0; i < numTables; i++) {
     3197    envelopes[i].x1 = DBL_MAX;
     3198    envelopes[i].x2 = DBL_MIN;
     3199    envelopes[i].y1 = DBL_MAX;
     3200    envelopes[i].y2 = DBL_MIN;
     3201  }
     3202
     3203  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     3204    if (blk1->tableId >= 0) {
     3205      if (blk1->ExMin < envelopes[blk1->tableId].x1) {
     3206        envelopes[blk1->tableId].x1 = blk1->ExMin;
     3207        if (!blk1->page->primaryLR)
     3208          ending_blocks[blk1->tableId] = blk1;
     3209      }
     3210
     3211      if (blk1->ExMax > envelopes[blk1->tableId].x2) {
     3212        envelopes[blk1->tableId].x2 = blk1->ExMax;
     3213        if (blk1->page->primaryLR)
     3214          ending_blocks[blk1->tableId] = blk1;
     3215      }
     3216
     3217      envelopes[blk1->tableId].y1 = blk1->EyMin < envelopes[blk1->tableId].y1 ?
     3218                                      blk1->EyMin : envelopes[blk1->tableId].y1;
     3219      envelopes[blk1->tableId].y2 = blk1->EyMax > envelopes[blk1->tableId].y2 ?
     3220                                      blk1->EyMax : envelopes[blk1->tableId].y2;
     3221    }
     3222  }
     3223
     3224  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     3225    if (blk1->tableId >= 0 &&
     3226        blk1->xMin <= ending_blocks[blk1->tableId]->xMax &&
     3227        blk1->xMax >= ending_blocks[blk1->tableId]->xMin) {
     3228      blk1->tableEnd = gTrue;
     3229    }
     3230  }
     3231
     3232  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     3233    if (blk1->tableId >= 0) {
     3234      blk1->ExMin = envelopes[blk1->tableId].x1;
     3235      blk1->ExMax = envelopes[blk1->tableId].x2;
     3236      blk1->EyMin = envelopes[blk1->tableId].y1;
     3237      blk1->EyMax = envelopes[blk1->tableId].y2;
     3238    }
     3239  }
     3240  delete[] envelopes;
     3241  delete[] ending_blocks;
     3242
     3243
     3244  /*  set extended bounding boxes of all other blocks
     3245   *  so that they extend in x without hitting neighbours
     3246   */
     3247  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     3248    if (!blk1->tableId >= 0) {
     3249      double xMax = DBL_MAX;
     3250      double xMin = DBL_MIN;
     3251
     3252      for (blk2 = blkList; blk2; blk2 = blk2->next) {
     3253        if (blk2 == blk1)
     3254           continue;
     3255
     3256        if (blk1->yMin <= blk2->yMax && blk1->yMax >= blk2->yMin) {
     3257          if (blk2->xMin < xMax && blk2->xMin > blk1->xMax)
     3258            xMax = blk2->xMin;
     3259
     3260          if (blk2->xMax > xMin && blk2->xMax < blk1->xMin)
     3261            xMin = blk2->xMax;
     3262        }
     3263      }
     3264
     3265      for (blk2 = blkList; blk2; blk2 = blk2->next) {
     3266        if (blk2 == blk1)
     3267           continue;
     3268
     3269        if (blk2->xMax > blk1->ExMax &&
     3270            blk2->xMax <= xMax &&
     3271            blk2->yMin >= blk1->yMax) {
     3272          blk1->ExMax = blk2->xMax;
     3273        }
     3274
     3275        if (blk2->xMin < blk1->ExMin &&
     3276            blk2->xMin >= xMin &&
     3277            blk2->yMin >= blk1->yMax)
     3278          blk1->ExMin = blk2->xMin;
     3279      }
     3280    }
     3281  }
     3282
    30003283  i = -1;
    30013284  for (blk1 = blkList; blk1; blk1 = blk1->next) {
     
    30733356    for (blk = flow->blocks; blk; blk = blk->next) {
    30743357      printf("  block: rot=%d x=%.2f..%.2f y=%.2f..%.2f pri=%.2f..%.2f\n",
    3075              blk->rot, blk->xMin, blk->xMax, blk->yMin, blk->yMax,
     3358             blk->rot, blk->ExMin, blk->ExMax, blk->EyMin, blk->EyMax,
    30763359             blk->priMin, blk->priMax);
    30773360      for (line = blk->lines; line; line = line->next) {
     
    36163899  GooString *s;
    36173900  TextLineFrag *frag;
    3618   int i;
     3901  int i, j;
    36193902  GBool multiLine;
    36203903  UnicodeMap *uMap;
    36213904  char space[8], eol[16];
    36223905  int spaceLen, eolLen;
     3906  GooList *strings = NULL;
     3907  int actual_table = -1;
     3908  int actual_line = -1;
     3909  int last_length = 0;
     3910  TextBlock *actual_block = NULL;
    36233911
    36243912  s = new GooString();
     
    36373925      frag = &frags[i];
    36383926
    3639       page->dumpFragment(frag->line->text + frag->start, frag->len, uMap, s);
    3640       s->append(eol, eolLen);
     3927      if (actual_table >= 0 && frag->line->blk->tableId < 0) {
     3928        for (j = 0; j < strings->getLength (); j++) {
     3929          s->append ((GooString*) strings->get (j));
     3930          s->append (eol, eolLen);
     3931          delete ((GooString*) strings->get (j));
     3932        }
     3933        delete strings;
     3934        strings = NULL;
     3935        actual_table = -1;
     3936        actual_line = -1;
     3937        actual_block = NULL;
     3938      }
     3939
     3940      // a table
     3941      if (frag->line->blk->tableId >= 0) {
     3942        if (actual_table == -1) {
     3943          strings = new GooList();
     3944          actual_table = frag->line->blk->tableId;
     3945          actual_block = frag->line->blk;
     3946          actual_line = -1;
     3947        }
     3948
     3949        // the same block
     3950        if (actual_block == frag->line->blk) {
     3951          actual_line++;
     3952          if (actual_line >= strings->getLength ()) {
     3953            GooString *t = new GooString ();
     3954            // add some spaces to have this block correctly aligned
     3955            if (actual_line > 0)
     3956              for (j = 0; j < ((GooString*) (strings->get (actual_line - 1)))->getLength() - last_length - 1; j++)
     3957                t->append (space, spaceLen);
     3958            strings->append (t);
     3959          }
     3960        }
     3961        // another block
     3962        else {
     3963          // previous block ended its row
     3964          if (actual_block->tableEnd) {
     3965            for (j = 0; j < strings->getLength (); j++) {
     3966              s->append ((GooString*) strings->get (j));
     3967              s->append (eol, eolLen);
     3968              delete ((GooString*) strings->get (j));
     3969            }
     3970            delete strings;
     3971
     3972            strings = new GooList();
     3973            GooString *t = new GooString ();
     3974            strings->append (t);
     3975          }
     3976          actual_block = frag->line->blk;
     3977          actual_line = 0;
     3978        }
     3979
     3980        page->dumpFragment(frag->line->text + frag->start, frag->len, uMap, ((GooString*) strings->get (actual_line)));
     3981        last_length = frag->len;
     3982
     3983        if (!frag->line->blk->tableEnd) {
     3984          ((GooString*) strings->get (actual_line))->append (space, spaceLen);
     3985        }
     3986      }
     3987      // not a table
     3988      else {
     3989        page->dumpFragment (frag->line->text + frag->start, frag->len, uMap, s);
     3990        s->append (eol, eolLen);
     3991      }
     3992    }
     3993
     3994    if (strings != NULL) {
     3995      for (j = 0; j < strings->getLength (); j++) {
     3996        s->append((GooString*) strings->get (j));
     3997        s->append(eol, eolLen);
     3998        delete ((GooString*) strings->get (j));
     3999      }
     4000      delete strings;
     4001      strings = NULL;
     4002      actual_table = -1;
     4003      actual_line = -1;
     4004      actual_block = NULL;
    36414005    }
    36424006  }
     
    38684232  current = NULL;
    38694233  for (p = words; p != NULL; p = p->next) {
    3870     if ((selection->x1 < p->xMax && selection->y1 < p->yMax) ||
    3871         (selection->x2 < p->xMax && selection->y2 < p->yMax))
    3872       if (begin == NULL)
    3873         begin = p;
    3874     if (((selection->x1 > p->xMin && selection->y1 > p->yMin) ||
    3875          (selection->x2 > p->xMin && selection->y2 > p->yMin)) && (begin != NULL)) {
    3876       end = p->next;
    3877       current = p;
     4234    if (blk->page->primaryLR) {
     4235      if ((selection->x1 < p->xMax && selection->y1 < p->yMax) ||
     4236          (selection->x2 < p->xMax && selection->y2 < p->yMax))
     4237        if (begin == NULL)
     4238          begin = p;
     4239
     4240      if (((selection->x1 > p->xMin && selection->y1 > p->yMin) ||
     4241           (selection->x2 > p->xMin && selection->y2 > p->yMin)) && (begin != NULL)) {
     4242        end = p->next;
     4243        current = p;
     4244      }
     4245    } else {
     4246      if ((selection->x1 > p->xMin && selection->y1 < p->yMax) ||
     4247          (selection->x2 > p->xMin && selection->y2 < p->yMax))
     4248        if (begin == NULL)
     4249          begin = p;
     4250
     4251      if (((selection->x1 < p->xMax && selection->y1 > p->yMin) ||
     4252           (selection->x2 < p->xMax && selection->y2 > p->yMin)) && (begin != NULL)) {
     4253        end = p->next;
     4254        current = p;
     4255      }
    38784256    }
    38794257  }
     
    46815059
    46825060  Object obj;
    4683   if (properties->lookup("ActualText", &obj)) {
     5061  if (properties && properties->lookup("ActualText", &obj)) {
    46845062    if (obj.isString()) {
    46855063      actualText = obj.getString();
     
    47745152      error(-1, "Couldn't open text file '%s'", fileName);
    47755153      ok = gFalse;
     5154      actualText = NULL;
    47765155      return;
    47775156    }
Note: See TracChangeset for help on using the changeset viewer.