File poppler-0.12.3-text-selection.patch of Package poppler

Overview Repositories Revisions Requests Users Attributes Meta

File poppler-0.12.3-text-selection.patch of Package poppler

--- poppler-0.12.3/poppler/TextOutputDev.cc	2009-10-05 00:40:39.000000000 +0200
+++ poppler-0.12.3/poppler/TextOutputDev.cc	2010-01-22 17:03:42.000000000 +0100
@@ -1615,6 +1615,144 @@ GBool TextBlock::isBelow(TextBlock *blk)
   return below;
 }
 
+GBool TextBlock::isBeforeByRule1(TextBlock *blk1) {
+  GBool before = gFalse;
+  GBool overlap = gFalse;
+
+  switch (this->page->primaryRot) {
+  case 0:
+  case 2:
+    overlap = ((this->xMin <= blk1->xMin) &&
+	       (blk1->xMin <= this->xMax)) ||
+      ((blk1->xMin <= this->xMin) &&
+       (this->xMin <= blk1->xMax));
+    break;
+  case 1:
+  case 3:
+    overlap = ((this->yMin <= blk1->yMin) &&
+	       (blk1->yMin <= this->yMax)) ||
+      ((blk1->yMin <= this->yMin) &&
+       (this->yMin <= blk1->yMax));
+    break;
+  }
+  switch (this->page->primaryRot) {
+  case 0:
+    before = overlap && this->yMin < blk1->yMin;
+    break;
+  case 1:
+    before = overlap && this->xMax > blk1->xMax;
+    break;
+  case 2:
+    before = overlap && this->yMax > blk1->yMax;
+    break;
+  case 3:
+    before = overlap && this->xMin < blk1->xMin;
+    break;
+  }
+  return before;
+}
+
+GBool TextBlock::isBeforeByRule2(TextBlock *blk1) {
+  double cmp = 0;
+  int rotLR = rot;
+
+  if (!page->primaryLR) {
+    rotLR = (rotLR + 2) % 4;
+  }
+
+  switch (rotLR) {
+  case 0:
+    cmp = xMax - blk1->xMin;
+    break;
+  case 1:
+    cmp = yMin - blk1->yMax;
+    break;
+  case 2:
+    cmp = blk1->xMax - xMin;
+    break;
+  case 3:
+    cmp = blk1->yMin - yMax;
+    break;
+  }
+  return cmp <= 0;
+}
+
+// Sort into reading order by performing a topological sort using the rules
+// given in "High Performance Document Layout Analysis", T.M. Breuel, 2003.
+// See http://pubs.iupr.org/#2003-breuel-sdiut
+// Topological sort is done by depth first search, see
+// http://en.wikipedia.org/wiki/Topological_sorting
+int TextBlock::visitDepthFirst(TextBlock *blkList, int pos1,
+			       TextBlock **sorted, int sortPos,
+			       GBool* visited) {
+  int pos2;
+  TextBlock *blk1, *blk2, *blk3;
+  GBool before;
+
+  if (visited[pos1]) {
+    return sortPos;
+  }
+
+  blk1 = this;
+
+#if 0 // for debugging
+  printf("visited: %d %.2f..%.2f %.2f..%.2f\n",
+	 sortPos, blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
+#endif
+  visited[pos1] = gTrue;
+  pos2 = -1;
+  for (blk2 = blkList; blk2; blk2 = blk2->next) {
+    pos2++;
+    if (visited[pos2]) {
+      // skip visited nodes
+      continue;
+    }
+    before = gFalse;
+    if (blk2->isBeforeByRule1(blk1)) {
+      // Rule (1) blk1 and blk2 overlap, and blk2 is above blk1.
+      before = gTrue;
+#if 0 // for debugging
+      printf("rule1: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
+	     blk2->xMin, blk2->xMax, blk2->yMin, blk2->yMax,
+	     blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
+#endif
+    } else if (blk2->isBeforeByRule2(blk1)) {
+      // Rule (2) blk2 left of blk1, and no intervening blk3
+      //          such that blk1 is before blk3 by rule 1,
+      //          and blk3 is before blk2 by rule 1.
+      before = gTrue;
+      for (blk3 = blkList; blk3; blk3 = blk3->next) {
+	if (blk3 == blk2 || blk3 == blk1) {
+	  continue;
+	}
+	if (blk1->isBeforeByRule1(blk3) &&
+	    blk3->isBeforeByRule1(blk2)) {
+	  before = gFalse;
+	  break;
+	}
+      }
+#if 0 // for debugging
+      if (before) {
+	printf("rule2: %.2f..%.2f %.2f..%.2f %.2f..%.2f %.2f..%.2f\n",
+	       blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax,
+	       blk2->xMin, blk2->xMax, blk2->yMin, blk2->yMax);
+      }
+#endif
+    }
+    if (before) {
+      // blk2 is before blk1, so it needs to be visited
+      // before we can add blk1 to the sorted list.
+      sortPos = blk2->visitDepthFirst(blkList, pos2, sorted, sortPos, visited);
+    }
+  }
+#if 0 // for debugging
+  printf("sorted: %d %.2f..%.2f %.2f..%.2f\n",
+	 sortPos, blk1->xMin, blk1->xMax, blk1->yMin, blk1->yMax);
+#endif
+  sorted[sortPos++] = blk1;
+  return sortPos;
+}
+
 //------------------------------------------------------------------------
 // TextFlow
 //------------------------------------------------------------------------
@@ -2183,8 +2321,7 @@ void TextPage::coalesce(GBool physLayout
   TextPool *pool;
   TextWord *word0, *word1, *word2;
   TextLine *line;
-  TextBlock *blkList, *blkStack, *blk, *lastBlk, *blk0, *blk1;
-  TextBlock **blkArray;
+  TextBlock *blkList, *blk, *lastBlk, *blk0, *blk1;
   TextFlow *flow, *lastFlow;
   TextUnderline *underline;
   TextLink *link;
@@ -2194,7 +2331,6 @@ void TextPage::coalesce(GBool physLayout
   GBool found;
   int count[4];
   int lrCount;
-  int firstBlkIdx, nBlocksLeft;
   int col1, col2;
   int i, j, n;
 
@@ -2687,7 +2823,7 @@ void TextPage::coalesce(GBool physLayout
     }
   }
 
-#if 0 // for debugging 
+#if 0 // for debugging
   printf("*** rotation ***\n");
   for (rot = 0; rot < 4; ++rot) {
     printf("  %d: %6d\n", rot, count[rot]);
@@ -2841,9 +2977,6 @@ void TextPage::coalesce(GBool physLayout
 
   //----- reading order sort
 
-  // sort blocks into yx order (in preparation for reading order sort)
-  qsort(blocks, nBlocks, sizeof(TextBlock *), &TextBlock::cmpYXPrimaryRot);
-
   // compute space on left and right sides of each block
   for (i = 0; i < nBlocks; ++i) {
     blk0 = blocks[i];
@@ -2856,7 +2989,25 @@ void TextPage::coalesce(GBool physLayout
   }
 
 #if 0 // for debugging
-  printf("*** blocks, after yx sort ***\n");
+  printf("PAGE\n");
+#endif
+
+  int sortPos = 0;
+  GBool *visited = (GBool *)gmallocn(nBlocks, sizeof(GBool));
+  for (i = 0; i < nBlocks; i++) {
+    visited[i] = gFalse;
+  }
+  i = -1;
+  for (blk1 = blkList; blk1; blk1 = blk1->next) {
+    i++;
+    sortPos = blk1->visitDepthFirst(blkList, i, blocks, sortPos, visited);
+  }
+  if (visited) {
+    gfree(visited);
+  }
+
+#if 0 // for debugging
+  printf("*** blocks, after ro sort ***\n");
   for (i = 0; i < nBlocks; ++i) {
     blk = blocks[i];
     printf("block: rot=%d x=%.2f..%.2f y=%.2f..%.2f space=%.2f..%.2f\n",
@@ -2876,44 +3027,34 @@ void TextPage::coalesce(GBool physLayout
     }
   }
   printf("\n");
+  fflush(stdout);
 #endif
 
   // build the flows
   //~ this needs to be adjusted for writing mode (vertical text)
   //~ this also needs to account for right-to-left column ordering
-  blkArray = (TextBlock **)gmallocn(nBlocks, sizeof(TextBlock *));
-  memcpy(blkArray, blocks, nBlocks * sizeof(TextBlock *));
+  flow = NULL;
   while (flows) {
     flow = flows;
     flows = flows->next;
     delete flow;
   }
   flows = lastFlow = NULL;
-  firstBlkIdx = 0;
-  nBlocksLeft = nBlocks;
-  while (nBlocksLeft > 0) {
-
-    // find the upper-left-most block
-    for (; !blkArray[firstBlkIdx]; ++firstBlkIdx) ;
-    i = firstBlkIdx;
-    blk = blkArray[i];
-    for (j = firstBlkIdx + 1; j < nBlocks; ++j) {
-      blk1 = blkArray[j];
-      if (blk1) {
-	if (blk && blk->secondaryDelta(blk1) > 0) {
-	  break;
-	}
-	if (blk1->primaryCmp(blk) < 0) {
-	  i = j;
-	  blk = blk1;
-	}
+  // assume blocks are already in reading order,
+  // and construct flows accordingly.
+  for (i = 0; i < nBlocks; i++) {
+    blk = blocks[i];
+    blk->next = NULL;
+    if (flow) {
+      blk1 = blocks[i - 1];
+      blkSpace = maxBlockSpacing * blk1->lines->words->fontSize;
+      if (blk1->secondaryDelta(blk) <= blkSpace &&
+	  blk->isBelow(blk1) &&
+	  flow->blockFits(blk, blk1)) {
+	flow->addBlock(blk);
+	continue;
       }
     }
-    blkArray[i] = NULL;
-    --nBlocksLeft;
-    blk->next = NULL;
-
-    // create a new flow, starting with the upper-left-most block
     flow = new TextFlow(this, blk);
     if (lastFlow) {
       lastFlow->next = flow;
@@ -2921,56 +3062,7 @@ void TextPage::coalesce(GBool physLayout
       flows = flow;
     }
     lastFlow = flow;
-    fontSize = blk->lines->words->fontSize;
-
-    // push the upper-left-most block on the stack
-    blk->stackNext = NULL;
-    blkStack = blk;
-
-    // find the other blocks in this flow
-    while (blkStack) {
-
-      // find the upper-left-most block under (but within
-      // maxBlockSpacing of) the top block on the stack
-      blkSpace = maxBlockSpacing * blkStack->lines->words->fontSize;
-      blk = NULL;
-      i = -1;
-      for (j = firstBlkIdx; j < nBlocks; ++j) {
-	blk1 = blkArray[j];
-	if (blk1) {
-	  if (blkStack->secondaryDelta(blk1) > blkSpace) {
-	    break;
-	  }
-	  if (blk && blk->secondaryDelta(blk1) > 0) {
-	    break;
-	  }
-	  if (blk1->isBelow(blkStack) &&
-	      (!blk || blk1->primaryCmp(blk) < 0)) {
-	    i = j;
-	    blk = blk1;
-	  }
-	}
-      }
-
-      // if a suitable block was found, add it to the flow and push it
-      // onto the stack
-      if (blk && flow->blockFits(blk, blkStack)) {
-	blkArray[i] = NULL;
-	--nBlocksLeft;
-	blk->next = NULL;
-	flow->addBlock(blk);
-	fontSize = blk->lines->words->fontSize;
-	blk->stackNext = blkStack;
-	blkStack = blk;
-
-      // otherwise (if there is no block under the top block or the
-      // block is not suitable), pop the stack
-      } else {
-	blkStack = blkStack->stackNext;
-      }
-    }
   }
-  gfree(blkArray);
 
 #if 0 // for debugging
   printf("*** flows ***\n");
@@ -3521,10 +3613,9 @@ void TextSelectionDumper::visitLine (Tex
 
 GooString *TextSelectionDumper::getText (void)
 {
-  GBool oneRot = gTrue;
   GooString *s;
   TextLineFrag *frag;
-  int i, col;
+  int i;
   GBool multiLine;
   UnicodeMap *uMap;
   char space[8], eol[16];
@@ -3541,45 +3632,11 @@ GooString *TextSelectionDumper::getText 
   eolLen = uMap->mapUnicode(0x0a, eol, sizeof(eol));
 
   if (nFrags > 0) {
-    for (i = 0; i < nFrags; ++i) {
-      frags[i].computeCoords(oneRot);
-    }
-    page->assignColumns(frags, nFrags, oneRot);
-
-    // if all lines in the region have the same rotation, use it;
-    // otherwise, use the page's primary rotation
-    if (oneRot) {
-      qsort(frags, nFrags, sizeof(TextLineFrag),
-	    &TextLineFrag::cmpYXLineRot);
-    } else {
-      qsort(frags, nFrags, sizeof(TextLineFrag),
-	    &TextLineFrag::cmpYXPrimaryRot);
-    }
-
-    col = 0;
     multiLine = gFalse;
     for (i = 0; i < nFrags; ++i) {
       frag = &frags[i];
 
-      // insert a return
-      if (frag->col < col ||
-	  (i > 0 && fabs(frag->base - frags[i-1].base) >
-	              maxIntraLineDelta * frags[i-1].line->words->fontSize)) {
-	  s->append(eol, eolLen);
-	col = 0;
-	multiLine = gTrue;
-      }
-
-      // column alignment
-      for (; col < frag->col; ++col) {
-	s->append(space, spaceLen);
-      }
-
-      // get the fragment text
-      col += page->dumpFragment(frag->line->text + frag->start, frag->len, uMap, s);
-    }
-
-    if (multiLine) {
+      page->dumpFragment(frag->line->text + frag->start, frag->len, uMap, s);
       s->append(eol, eolLen);
     }
   }
@@ -3859,75 +3916,112 @@ void TextLine::visitSelection(TextSelect
 void TextBlock::visitSelection(TextSelectionVisitor *visitor,
 			       PDFRectangle *selection,
 			       SelectionStyle style) {
-  TextLine *p, *begin, *end;
   PDFRectangle child_selection;
-  double start_x, start_y, stop_x, stop_y;
-
-  begin = NULL;
-  end = NULL;
-  start_x = selection->x1;
-  start_y = selection->y1;
-  stop_x = selection->x2;
-  stop_y = selection->y2;
-  
-  for (p = lines; p != NULL; p = p->next) {
-    if (selection->x1 < p->xMax && selection->y1 < p->yMax && 
-	selection->x2 < p->xMax && selection->y2 < p->yMax && begin == NULL) {
-      begin = p;
-      if (selection->x1 < selection->x2) {
-	start_x = selection->x1;
-	start_y = selection->y1;
-	stop_x = selection->x2;
-	stop_y = selection->y2;
+  double x[2], y[2], d, best_d[2];
+  TextLine *p, *best_line[2];
+  int i, count = 0, best_count[2], start, stop;
+  GBool all[2];
+
+  x[0] = selection->x1;
+  y[0] = selection->y1;
+  x[1] = selection->x2;
+  y[1] = selection->y2;
+
+  for (i = 0; i < 2; i++) {
+    // the first/last lines are often not nearest
+    // the corners, so we have to force them to be
+    // selected when the selection runs outside this
+    // block.
+    if (page->primaryLR) {
+      all[i] = x[i] >= this->xMax && y[i] >= this->yMax;
+      if (x[i] <= this->xMin && y[i] <= this->yMin) {
+	best_line[i] = this->lines;
+	best_count[i] = 1;
       } else {
-	start_x = selection->x2;
-	start_y = selection->y2;
-	stop_x = selection->x1;
-	stop_y = selection->y1;
-      }
-    } else if (selection->x1 < p->xMax && selection->y1 < p->yMax && begin == NULL) {
-      begin = p;
-      start_x = selection->x1;
-      start_y = selection->y1;
-      stop_x = selection->x2;
-      stop_y = selection->y2;
-    } else if (selection->x2 < p->xMax && selection->y2 < p->yMax && begin == NULL) {
-      begin = p;
-      start_x = selection->x2;
-      start_y = selection->y2;
-      stop_x = selection->x1;
-      stop_y = selection->y1;
+	best_line[i] = NULL;
+	best_count[i] = 0;
+      }
+    } else {
+      all[i] = x[i] <= this->xMin && y[i] >= this->yMax;
+      if (x[i] >= this->xMax && y[i] <= this->yMin) {
+	best_line[i] = this->lines;
+	best_count[i] = 1;
+      } else {
+	best_line[i] = NULL;
+	best_count[i] = 0;
+      }
     }
-
-    if (((selection->x1 > p->xMin && selection->y1 > p->yMin) ||
-	 (selection->x2 > p->xMin && selection->y2 > p->yMin))
-	&& (begin != NULL))
-      end = p->next;
+    best_d[i] = 0;
   }
 
-  /* Skip empty selection. */
-  if (end == begin)
+  // find the nearest line to the selection points
+  // using the manhattan distance.
+  for (p = this->lines; p; p = p->next) {
+    count++;
+    for (i = 0; i < 2; i++) {
+      d = fmax(p->xMin - x[i], 0.0) +
+	fmax(x[i] - p->xMax, 0.0) +
+	fmax(p->yMin - y[i], 0.0) +
+	fmax(y[i] - p->yMax, 0.0);
+      if (!best_line[i] || all[i] ||
+	  d < best_d[i]) {
+	best_line[i] = p;
+	best_count[i] = count;
+	best_d[i] = d;
+      }
+    }
+  }
+  // assert: best is always set.
+  if (!best_line[0] || !best_line[1]) {
     return;
+  }
+
+  // Now decide which point was first.
+  if (best_count[0] < best_count[1] ||
+      (best_count[0] == best_count[1] &&
+       y[0] < y[1])) {
+    start = 0;
+    stop = 1;
+  } else {
+    start = 1;
+    stop = 0;
+  }
 
-  visitor->visitBlock (this, begin, end, selection);
+  visitor->visitBlock(this, best_line[start], best_line[stop], selection);
 
-  for (p = begin; p != end; p = p->next) {
-    if (p == begin && style != selectionStyleLine) {
-      child_selection.x1 = start_x;
-      child_selection.y1 = start_y;
+  for (p = best_line[start]; p; p = p->next) {
+    if (page->primaryLR) {
+      child_selection.x1 = p->xMin;
+      child_selection.x2 = p->xMax;
     } else {
-      child_selection.x1 = 0;
-      child_selection.y1 = 0;
+      child_selection.x1 = p->xMax;
+      child_selection.x2 = p->xMin;
     }
-    if (p->next == end && style != selectionStyleLine) {
-      child_selection.x2 = stop_x;
-      child_selection.y2 = stop_y;
+    child_selection.y1 = p->yMin;
+    child_selection.y2 = p->yMax;
+    if (style == selectionStyleLine) {
+      if (p == best_line[start]) {
+	child_selection.x1 = 0;
+	child_selection.y1 = 0;
+      }
+      if (p == best_line[stop]) {
+	child_selection.x2 = page->pageWidth;
+	child_selection.y2 = page->pageHeight;
+      }
     } else {
-      child_selection.x2 = page->pageWidth;
-      child_selection.y2 = page->pageHeight;
+      if (p == best_line[start]) {
+	child_selection.x1 = fmax(p->xMin, fmin(p->xMax, x[start]));
+	child_selection.y1 = fmax(p->yMin, fmin(p->yMax, y[start]));
+      }
+      if (p == best_line[stop]) {
+	child_selection.x2 = fmax(p->xMin, fmin(p->xMax, x[stop]));
+	child_selection.y2 = fmax(p->yMin, fmin(p->yMax, y[stop]));
+      }
     }
-
     p->visitSelection(visitor, &child_selection, style);
+    if (p == best_line[stop]) {
+      return;
+    }
   }
 }
 
@@ -3935,73 +4029,122 @@ void TextPage::visitSelection(TextSelect
 			      PDFRectangle *selection,
 			      SelectionStyle style)
 {
-  int i, begin, end;
   PDFRectangle child_selection;
-  double start_x, start_y, stop_x, stop_y;
-  TextBlock *b;
+  double x[2], y[2], d, best_d[2];
+  double xMin, yMin, xMax, yMax;
+  TextFlow *flow, *best_flow[2];
+  TextBlock *blk, *best_block[2];
+  int i, count = 0, best_count[2], start, stop;
 
-  begin = nBlocks;
-  end = 0;
-  start_x = selection->x1;
-  start_y = selection->y1;
-  stop_x = selection->x2;
-  stop_y = selection->y2;
+  if (!flows)
+    return;
 
-  for (i = 0; i < nBlocks; i++) {
-    b = blocks[i];
+  x[0] = selection->x1;
+  y[0] = selection->y1;
+  x[1] = selection->x2;
+  y[1] = selection->y2;
+
+  xMin = pageWidth;
+  yMin = pageHeight;
+  xMax = 0.0;
+  yMax = 0.0;
+
+  for (i = 0; i < 2; i++) {
+    best_block[i] = NULL;
+    best_flow[i] = NULL;
+    best_count[i] = 0;
+    best_d[i] = 0;
+  }
 
-    if (selection->x1 < b->xMax && selection->y1 < b->yMax &&
-	selection->x2 < b->xMax && selection->y2 < b->yMax && i < begin) {
-      begin = i;
-      if (selection->y1 < selection->y2) {
-	start_x = selection->x1;
-	start_y = selection->y1;
-	stop_x = selection->x2;
-	stop_y = selection->y2;
-      } else {
-	start_x = selection->x2;
-	start_y = selection->y2;
-	stop_x = selection->x1;
-	stop_y = selection->y1;
-      }
-    } else if (selection->x1 < b->xMax && selection->y1 < b->yMax && i < begin) {
-      begin = i;
-      start_x = selection->x1;
-      start_y = selection->y1;
-      stop_x = selection->x2;
-      stop_y = selection->y2;
-    } else if (selection->x2 < b->xMax && selection->y2 < b->yMax && i < begin) {
-      begin = i;
-      start_x = selection->x2;
-      start_y = selection->y2;
-      stop_x = selection->x1;
-      stop_y = selection->y1;
+  // find the nearest blocks to the selection points
+  // using the manhattan distance.
+  for (flow = flows; flow; flow = flow->next) {
+    for (blk = flow->blocks; blk; blk = blk->next) {
+      count++;
+      // the first/last blocks in reading order are
+      // often not the closest to the page corners;
+      // track the corners, force those blocks to
+      // be selected if the selection runs across
+      // multiple pages.
+      xMin = fmin(xMin, blk->xMin);
+      yMin = fmin(yMin, blk->yMin);
+      xMax = fmax(xMax, blk->xMax);
+      yMax = fmax(yMax, blk->yMax);
+      for (i = 0; i < 2; i++) {
+	d = fmax(blk->xMin - x[i], 0.0) +
+	  fmax(x[i] - blk->xMax, 0.0) +
+	  fmax(blk->yMin - y[i], 0.0) +
+	  fmax(y[i] - blk->yMax, 0.0);
+	if (!best_block[i] ||
+	    d < best_d[i] ||
+	    (!blk->next && !flow->next &&
+	     x[i] > xMax && y[i] > yMax)) {
+	  best_block[i] = blk;
+	  best_flow[i] = flow;
+	  best_count[i] = count;
+	  best_d[i] = d;
+	}
+      }
     }
+  }
+  for (i = 0; i < 2; i++) {
+    if (primaryLR) {
+      if (x[i] < xMin && y[i] < yMin) {
+	best_block[i] = flows->blocks;
+	best_flow[i] = flows;
+	best_count[i] = 1;
+      }
+    } else {
+      if (x[i] > xMax && y[i] < yMin) {
+	best_block[i] = flows->blocks;
+	best_flow[i] = flows;
+	best_count[i] = 1;
+      }
+    }
+  }
+  // assert: best is always set.
+  if (!best_block[0] || !best_block[1]) {
+    return;
+  }
 
-    if ((selection->x1 > b->xMin && selection->y1 > b->yMin) ||
-	(selection->x2 > b->xMin && selection->y2 > b->yMin))
-      end = i + 1;
+  // Now decide which point was first.
+  if (best_count[0] < best_count[1] ||
+      (best_count[0] == best_count[1] && y[0] < y[1])) {
+    start = 0;
+    stop = 1;
+  } else {
+    start = 1;
+    stop = 0;
   }
 
-  for (i = begin; i < end; i++) {
-    if (blocks[i]->xMin < start_x && start_x < blocks[i]->xMax &&
-	blocks[i]->yMin < start_y && start_y < blocks[i]->yMax) {
-      child_selection.x1 = start_x;
-      child_selection.y1 = start_y;
+  for (flow = best_flow[start]; flow; flow = flow->next) {
+    if (flow == best_flow[start]) {
+      blk = best_block[start];
     } else {
-      child_selection.x1 = 0;
-      child_selection.y1 = 0;
+      blk = flow->blocks;
     }
-    if (blocks[i]->xMin < stop_x && stop_x < blocks[i]->xMax &&
-	blocks[i]->yMin < stop_y && stop_y < blocks[i]->yMax) {
-      child_selection.x2 = stop_x;
-      child_selection.y2 = stop_y;
-    } else {
-      child_selection.x2 = pageWidth;
-      child_selection.y2 = pageHeight;
+    for (; blk; blk = blk->next) {
+      if (primaryLR) {
+	child_selection.x1 = blk->xMin;
+	child_selection.x2 = blk->xMax;
+      } else {
+	child_selection.x1 = blk->xMax;
+	child_selection.x2 = blk->xMin;
+      }
+      child_selection.y1 = blk->yMin;
+      child_selection.y2 = blk->yMax;
+      if (blk == best_block[start]) {
+	child_selection.x1 = fmax(blk->xMin, fmin(blk->xMax, x[start]));
+	child_selection.y1 = fmax(blk->yMin, fmin(blk->yMax, y[start]));
+      }
+      if (blk == best_block[stop]) {
+	child_selection.x2 = fmax(blk->xMin, fmin(blk->xMax, x[stop]));
+	child_selection.y2 = fmax(blk->yMin, fmin(blk->yMax, y[stop]));
+	blk->visitSelection(visitor, &child_selection, style);
+	return;
+      }
+      blk->visitSelection(visitor, &child_selection, style);
     }
-
-    blocks[i]->visitSelection(visitor, &child_selection, style);
   }
 }
 
@@ -4286,24 +4429,13 @@ void TextPage::dump(void *outputStream, 
 	  dumpFragment(line->text, n, uMap, s);
 	  (*outputFunc)(outputStream, s->getCString(), s->getLength());
 	  delete s;
-	  if (!line->hyphenated) {
-	    if (line->next) {
-	      (*outputFunc)(outputStream, space, spaceLen);
-	    } else if (blk->next) {
-	      //~ this is a bit of a kludge - we should really do a more
-	      //~ intelligent determination of paragraphs
-	      if (blk->next->lines->words->fontSize ==
-		  blk->lines->words->fontSize) {
-		(*outputFunc)(outputStream, space, spaceLen);
-	      } else {
-		(*outputFunc)(outputStream, eol, eolLen);
-	      }
-	    }
+	  // output a newline when a hyphen is not suppressed
+	  if (n == line->len) {
+	    (*outputFunc)(outputStream, eol, eolLen);
 	  }
 	}
       }
       (*outputFunc)(outputStream, eol, eolLen);
-      (*outputFunc)(outputStream, eol, eolLen);
     }
   }
 
--- poppler-0.12.3/poppler/TextOutputDev.h	2009-09-09 23:22:31.000000000 +0200
+++ poppler-0.12.3/poppler/TextOutputDev.h	2010-01-22 17:03:34.000000000 +0100
@@ -361,6 +361,14 @@ public:
 
 private:
 
+  GBool isBeforeByRule1(TextBlock *blk1);
+  GBool isBeforeByRepeatedRule1(TextBlock *blkList, TextBlock *blk1);
+  GBool isBeforeByRule2(TextBlock *blk1);
+
+  int visitDepthFirst(TextBlock *blkList, int pos1,
+		      TextBlock **sorted, int sortPos,
+		      GBool* visited);
+
   TextPage *page;		// the parent page
   int rot;			// text rotation
   double xMin, xMax;		// bounding box x coordinates

Places

File poppler-0.12.3-text-selection.patch of Package poppler

Places