diff options
Diffstat (limited to 'xpdf/TextOutputDev.h')
| -rw-r--r-- | xpdf/TextOutputDev.h | 800 |
1 files changed, 800 insertions, 0 deletions
diff --git a/xpdf/TextOutputDev.h b/xpdf/TextOutputDev.h new file mode 100644 index 0000000..302975c --- /dev/null +++ b/xpdf/TextOutputDev.h @@ -0,0 +1,800 @@ +//======================================================================== +// +// TextOutputDev.h +// +// Copyright 1997-2012 Glyph & Cog, LLC +// +//======================================================================== + +#ifndef TEXTOUTPUTDEV_H +#define TEXTOUTPUTDEV_H + +#include <aconf.h> + +#ifdef USE_GCC_PRAGMAS +#pragma interface +#endif + +#include <stdio.h> +#include "gtypes.h" +#include "GfxFont.h" +#include "OutputDev.h" + +class GList; +class UnicodeMap; +class UnicodeRemapping; + +class TextBlock; +class TextChar; +class TextGaps; +class TextLink; +class TextPage; + +//------------------------------------------------------------------------ + +typedef void (*TextOutputFunc)(void *stream, const char *text, int len); + +//------------------------------------------------------------------------ +// TextOutputControl +//------------------------------------------------------------------------ + +enum TextOutputMode { + textOutReadingOrder, // format into reading order + textOutPhysLayout, // maintain original physical layout + textOutSimpleLayout, // simple one-column physical layout + textOutSimple2Layout, // simple one-column physical layout + textOutTableLayout, // similar to PhysLayout, but optimized + // for tables + textOutLinePrinter, // strict fixed-pitch/height layout + textOutRawOrder // keep text in content stream order +}; + +enum TextOutputOverlapHandling { + textOutIgnoreOverlaps, // no special handling for overlaps + textOutAppendOverlaps, // append overlapping text to main text + textOutDiscardOverlaps // discard overlapping text +}; + +class TextOutputControl { +public: + + TextOutputControl(); + ~TextOutputControl() {} + + TextOutputMode mode; // formatting mode + double fixedPitch; // if this is non-zero, assume fixed-pitch + // characters with this width + // (only relevant for PhysLayout, Table, + // and LinePrinter modes) + double fixedLineSpacing; // fixed line spacing (only relevant for + // LinePrinter mode) + GBool html; // enable extra processing for HTML + GBool clipText; // separate clipped text and add it back + // in after forming columns + GBool discardDiagonalText; // discard all text that's not close to + // 0/90/180/270 degrees + GBool discardRotatedText; // discard all text that's not horizontal + // (0 degrees) + GBool discardInvisibleText; // discard all invisible characters + GBool discardClippedText; // discard all clipped characters + GBool splitRotatedWords; // do not combine horizontal and + // non-horizontal chars in a single + // word + TextOutputOverlapHandling // how to handle overlapping text + overlapHandling; + GBool separateLargeChars; // separate "large" characters from + // "regular" characters + GBool insertBOM; // insert a Unicode BOM at the start of + // the text output + double marginLeft, // characters outside the margins are + marginRight, // discarded + marginTop, + marginBottom; +}; + +//------------------------------------------------------------------------ +// TextFontInfo +//------------------------------------------------------------------------ + +class TextFontInfo { +public: + + // Create a TextFontInfo for the current font in [state]. + TextFontInfo(GfxState *state); + + // Create a dummy TextFontInfo. + TextFontInfo(); + + ~TextFontInfo(); + + GBool matches(GfxState *state); + + // Get the font name (which may be NULL). + GString *getFontName() { return fontName; } + + // Get font descriptor flags. + GBool isFixedWidth() { return flags & fontFixedWidth; } + GBool isSerif() { return flags & fontSerif; } + GBool isSymbolic() { return flags & fontSymbolic; } + GBool isItalic() { return flags & fontItalic; } + GBool isBold() { return flags & fontBold; } + + // Get the width of the 'm' character, if available. + double getMWidth() { return mWidth; } + + Ref getFontID() { return fontID; } + +private: + + Ref fontID; + GString *fontName; + int flags; + double mWidth; + double ascent, descent; + + friend class TextLine; + friend class TextPage; + friend class TextWord; +}; + +//------------------------------------------------------------------------ +// TextWord +//------------------------------------------------------------------------ + +class TextWord { +public: + + TextWord(GList *chars, int start, int lenA, + int rotA, GBool rotatedA, int dirA, GBool spaceAfterA); + ~TextWord(); + TextWord *copy() { return new TextWord(this); } + + // Get the TextFontInfo object associated with this word. + TextFontInfo *getFontInfo() { return font; } + + int getLength() { return len; } + Unicode getChar(int idx) { return text[idx]; } + GString *getText(); + GString *getFontName() { return font->fontName; } + void getColor(double *r, double *g, double *b) + { *r = colorR; *g = colorG; *b = colorB; } + GBool isInvisible() { return invisible; } + void getBBox(double *xMinA, double *yMinA, double *xMaxA, double *yMaxA) + { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; } + void getCharBBox(int charIdx, double *xMinA, double *yMinA, + double *xMaxA, double *yMaxA); + double getFontSize() { return fontSize; } + int getRotation() { return rot; } + GBool isRotated() { return (GBool)rotated; } + int getCharPos() { return charPos[0]; } + int getCharLen() { return charPos[len] - charPos[0]; } + int getDirection() { return dir; } + GBool getSpaceAfter() { return spaceAfter; } + double getBaseline(); + GBool isUnderlined() { return underlined; } + GString *getLinkURI(); + +private: + + TextWord(TextWord *word); + static int cmpYX(const void *p1, const void *p2); + static int cmpCharPos(const void *p1, const void *p2); + + double xMin, xMax; // bounding box x coordinates + double yMin, yMax; // bounding box y coordinates + Unicode *text; // the text + int *charPos; // character position (within content stream) + // of each char (plus one extra entry for + // the last char) + double *edge; // "near" edge x or y coord of each char + // (plus one extra entry for the last char) + int len; // number of characters + TextFontInfo *font; // font information + double fontSize; // font size + TextLink *link; + double colorR, // word color + colorG, + colorB; + GBool invisible; // set for invisible text (render mode 3) + + // group the byte-size fields to minimize object size + Guchar rot; // rotation, multiple of 90 degrees + // (0, 1, 2, or 3) + char rotated; // set if this word is non-horizontal + char dir; // character direction (+1 = left-to-right; + // -1 = right-to-left; 0 = neither) + char spaceAfter; // set if there is a space between this + // word and the next word on the line + char underlined; + + friend class TextBlock; + friend class TextLine; + friend class TextPage; +}; + +//------------------------------------------------------------------------ +// TextLine +//------------------------------------------------------------------------ + +class TextLine { +public: + + TextLine(GList *wordsA, double xMinA, double yMinA, + double xMaxA, double yMaxA, double fontSizeA); + ~TextLine(); + + double getXMin() { return xMin; } + double getYMin() { return yMin; } + double getXMax() { return xMax; } + double getYMax() { return yMax; } + double getBaseline(); + int getRotation() { return rot; } + GList *getWords() { return words; } + Unicode *getUnicode() { return text; } + int getLength() { return len; } + double getEdge(int idx) { return edge[idx]; } + GBool getHyphenated() { return hyphenated; } + +private: + + static int cmpX(const void *p1, const void *p2); + + GList *words; // [TextWord] + int rot; // rotation, multiple of 90 degrees + // (0, 1, 2, or 3) + double xMin, xMax; // bounding box x coordinates + double yMin, yMax; // bounding box y coordinates + double fontSize; // main (max) font size for this line + Unicode *text; // Unicode text of the line, including + // spaces between words + double *edge; // "near" edge x or y coord of each char + // (plus one extra entry for the last char) + int len; // number of Unicode chars + GBool hyphenated; // set if last char is a hyphen + int px; // x offset (in characters, relative to + // containing column) in physical layout mode + int pw; // line width (in characters) in physical + // layout mode + + friend class TextSuperLine; + friend class TextPage; + friend class TextParagraph; +}; + +//------------------------------------------------------------------------ +// TextParagraph +//------------------------------------------------------------------------ + +class TextParagraph { +public: + + TextParagraph(GList *linesA, GBool dropCapA); + ~TextParagraph(); + + // Get the list of TextLine objects. + GList *getLines() { return lines; } + + GBool hasDropCap() { return dropCap; } + + double getXMin() { return xMin; } + double getYMin() { return yMin; } + double getXMax() { return xMax; } + double getYMax() { return yMax; } + +private: + + GList *lines; // [TextLine] + GBool dropCap; // paragraph starts with a drop capital + double xMin, xMax; // bounding box x coordinates + double yMin, yMax; // bounding box y coordinates + + friend class TextPage; +}; + +//------------------------------------------------------------------------ +// TextColumn +//------------------------------------------------------------------------ + +class TextColumn { +public: + + TextColumn(GList *paragraphsA, double xMinA, double yMinA, + double xMaxA, double yMaxA); + ~TextColumn(); + + // Get the list of TextParagraph objects. + GList *getParagraphs() { return paragraphs; } + + double getXMin() { return xMin; } + double getYMin() { return yMin; } + double getXMax() { return xMax; } + double getYMax() { return yMax; } + + int getRotation(); + +private: + + static int cmpX(const void *p1, const void *p2); + static int cmpY(const void *p1, const void *p2); + static int cmpPX(const void *p1, const void *p2); + + GList *paragraphs; // [TextParagraph] + double xMin, xMax; // bounding box x coordinates + double yMin, yMax; // bounding box y coordinates + int px, py; // x, y position (in characters) in physical + // layout mode + int pw, ph; // column width, height (in characters) in + // physical layout mode + + friend class TextPage; +}; + +//------------------------------------------------------------------------ +// TextWordList +//------------------------------------------------------------------------ + +class TextWordList { +public: + + TextWordList(GList *wordsA, GBool primaryLRA); + + ~TextWordList(); + + // Return the number of words on the list. + int getLength(); + + // Return the <idx>th word from the list. + TextWord *get(int idx); + + // Returns true if primary direction is left-to-right, or false if + // right-to-left. + GBool getPrimaryLR() { return primaryLR; } + +private: + + GList *words; // [TextWord] + GBool primaryLR; +}; + +//------------------------------------------------------------------------ +// TextPosition +//------------------------------------------------------------------------ + +// Position within a TextColumn tree. The position is in column +// [colIdx], paragraph [parIdx], line [lineIdx], before character +// [charIdx]. +class TextPosition { +public: + + TextPosition(): colIdx(0), parIdx(0), lineIdx(0), charIdx(0) {} + TextPosition(int colIdxA, int parIdxA, int lineIdxA, int charIdxA): + colIdx(colIdxA), parIdx(parIdxA), lineIdx(lineIdxA), charIdx(charIdxA) {} + + int operator==(TextPosition pos); + int operator!=(TextPosition pos); + int operator<(TextPosition pos); + int operator>(TextPosition pos); + + int colIdx, parIdx, lineIdx, charIdx; +}; + +//------------------------------------------------------------------------ +// TextPage +//------------------------------------------------------------------------ + +class TextPage { +public: + + TextPage(TextOutputControl *controlA); + ~TextPage(); + + // Write contents of page to a stream. + void write(void *outputStream, TextOutputFunc outputFunc); + + // Find a string. If <startAtTop> is true, starts looking at the + // top of the page; else if <startAtLast> is true, starts looking + // immediately after the last find result; else starts looking at + // <xMin>,<yMin>. If <stopAtBottom> is true, stops looking at the + // bottom of the page; else if <stopAtLast> is true, stops looking + // just before the last find result; else stops looking at + // <xMax>,<yMax>. + GBool findText(Unicode *s, int len, + GBool startAtTop, GBool stopAtBottom, + GBool startAtLast, GBool stopAtLast, + GBool caseSensitive, GBool backward, + GBool wholeWord, + double *xMin, double *yMin, + double *xMax, double *yMax); + + // Get the text which is inside the specified rectangle. Multi-line + // text always includes end-of-line markers at the end of each line. + // If <forceEOL> is true, an end-of-line marker will be appended to + // single-line text as well. + GString *getText(double xMin, double yMin, + double xMax, double yMax, + GBool forceEOL = gFalse); + + // Find a string by character position and length. If found, sets + // the text bounding rectangle and returns true; otherwise returns + // false. + GBool findCharRange(int pos, int length, + double *xMin, double *yMin, + double *xMax, double *yMax); + + // Returns true if x,y falls inside a column. + GBool checkPointInside(double x, double y); + + // Find a point inside a column. Returns false if x,y fall outside + // all columns. + GBool findPointInside(double x, double y, TextPosition *pos); + + // Find a point in the nearest column. Returns false only if there + // are no columns. + GBool findPointNear(double x, double y, TextPosition *pos); + + // Find the start and end of a word inside a column. Returns false + // if x,y fall outside all columns. + GBool findWordPoints(double x, double y, + TextPosition *startPos, TextPosition *endPos); + + // Find the start and end of a line inside a column. Returns false + // if x,y fall outside all columns. + GBool findLinePoints(double x, double y, + TextPosition *startPos, TextPosition *endPos); + + // Get the upper point of a TextPosition. + void convertPosToPointUpper(TextPosition *pos, double *x, double *y); + + // Get the lower point of a TextPosition. + void convertPosToPointLower(TextPosition *pos, double *x, double *y); + + // Get the upper left corner of the line containing a TextPosition. + void convertPosToPointLeftEdge(TextPosition *pos, double *x, double *y); + + // Get the lower right corner of the line containing a TextPosition. + void convertPosToPointRightEdge(TextPosition *pos, double *x, double *y); + + // Get the upper right corner of a column. + void getColumnUpperRight(int colIdx, double *x, double *y); + + // Get the lower left corner of a column. + void getColumnLowerLeft(int colIdx, double *x, double *y); + + // Create and return a list of TextColumn objects. + GList *makeColumns(); + + // Get the list of all TextFontInfo objects used on this page. + GList *getFonts() { return fonts; } + + // Build a flat word list, in the specified ordering. + TextWordList *makeWordList(); + + // Build a word list containing only words inside the specified + // rectangle. + TextWordList *makeWordListForRect(double xMin, double yMin, + double xMax, double yMax); + + // Returns true if the primary character direction is left-to-right, + // false if it is right-to-left. + GBool primaryDirectionIsLR(); + + // Returns true if any of the fonts used on this page are likely to + // be problematic when converting text to Unicode. + GBool problematicForUnicode() { return problematic; } + + // Add a 'special' character to this TextPage. This is currently + // used by pdftohtml to insert markers for form fields. + void addSpecialChar(double xMin, double yMin, double xMax, double yMax, + int rot, TextFontInfo *font, double fontSize, + Unicode u); + + // Remove characters that fall inside a region. + void removeChars(double xMin, double yMin, double xMax, double yMax, + double xOverlapThresh, double yOverlapThresh); + +private: + + void startPage(GfxState *state); + void clear(); + void updateFont(GfxState *state); + void addChar(GfxState *state, double x, double y, + double dx, double dy, + CharCode c, int nBytes, Unicode *u, int uLen); + void incCharCount(int nChars); + void beginActualText(GfxState *state, Unicode *u, int uLen); + void endActualText(GfxState *state); + void addUnderline(double x0, double y0, double x1, double y1); + void addLink(double xMin, double yMin, double xMax, double yMax, + Link *link); + + // output + void writeReadingOrder(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void writePhysLayout(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void writeSimpleLayout(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void writeSimple2Layout(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void writeLinePrinter(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void writeRaw(void *outputStream, + TextOutputFunc outputFunc, + UnicodeMap *uMap, + char *space, int spaceLen, + char *eol, int eolLen); + void encodeFragment(Unicode *text, int len, UnicodeMap *uMap, + GBool primaryLR, GString *s); + GBool unicodeEffectiveTypeLOrNum(Unicode u, Unicode left, Unicode right); + GBool unicodeEffectiveTypeR(Unicode u, Unicode left, Unicode right); + + // analysis + int rotateChars(GList *charsA); + void rotateCharsToZero(GList *charsA); + void rotateUnderlinesAndLinks(int rot); + void unrotateChars(GList *charsA, int rot); + void unrotateCharsFromZero(GList *charsA); + void unrotateColumnsFromZero(GList *columns); + void unrotateColumns(GList *columns, int rot); + void unrotateWords(GList *words, int rot); + GBool checkPrimaryLR(GList *charsA); + void removeDuplicates(GList *charsA, int rot); + GList *separateOverlappingText(GList *charsA); + TextColumn *buildOverlappingTextColumn(GList *overlappingChars); + TextBlock *splitChars(GList *charsA); + TextBlock *split(GList *charsA, int rot, GBool vertOnly); + GList *getChars(GList *charsA, double xMin, double yMin, + double xMax, double yMax); + void findGaps(GList *charsA, int rot, + double *xMinOut, double *yMinOut, + double *xMaxOut, double *yMaxOut, + double *avgFontSizeOut, double *minFontSizeOut, + GList *splitLines, + TextGaps *horizGaps, TextGaps *vertGaps); + void mergeSplitLines(GList *charsA, int rot, GList *splitLines); + void tagBlock(TextBlock *blk); + void insertLargeChars(GList *largeChars, TextBlock *blk); + void insertLargeCharsInFirstLeaf(GList *largeChars, TextBlock *blk); + void insertLargeCharInLeaf(TextChar *ch, TextBlock *blk); + void insertIntoTree(TextBlock *subtree, TextBlock *primaryTree); + void insertColumnIntoTree(TextBlock *column, TextBlock *tree); + void insertClippedChars(GList *clippedChars, TextBlock *tree); + TextBlock *findClippedCharLeaf(TextChar *ch, TextBlock *tree); + GList *buildColumns(TextBlock *tree, GBool primaryLR); + void buildColumns2(TextBlock *blk, GList *columns, GBool primaryLR); + TextColumn *buildColumn(TextBlock *tree); + double getLineIndent(TextLine *line, TextBlock *blk); + double getAverageLineSpacing(GList *lines); + double getLineSpacing(TextLine *line0, TextLine *line1); + void buildLines(TextBlock *blk, GList *lines, GBool splitSuperLines); + GList *buildSimple2Columns(GList *charsA); + GList *buildSimple2Lines(GList *charsA, int rot); + TextLine *buildLine(TextBlock *blk); + TextLine *buildLine(GList *charsA, int rot, + double xMin, double yMin, double xMax, double yMax); + void getLineChars(TextBlock *blk, GList *charsA); + double computeWordSpacingThreshold(GList *charsA, int rot); + int getCharDirection(TextChar *ch); + int getCharDirection(TextChar *ch, TextChar *left, TextChar *right); + int assignPhysLayoutPositions(GList *columns); + void assignLinePhysPositions(GList *columns); + void computeLinePhysWidth(TextLine *line, UnicodeMap *uMap); + int assignColumnPhysPositions(GList *columns); + void buildSuperLines(TextBlock *blk, GList *superLines); + void assignSimpleLayoutPositions(GList *superLines, UnicodeMap *uMap); + void generateUnderlinesAndLinks(GList *columns); + void findPointInColumn(TextColumn *col, double x, double y, + TextPosition *pos); + void buildFindCols(); + + // debug +#if 0 //~debug + void dumpChars(GList *charsA); + void dumpTree(TextBlock *tree, int indent = 0); + void dumpColumns(GList *columns, GBool dumpWords = gFalse); + void dumpUnderlines(); +#endif + + // word list + TextWordList *makeWordListForChars(GList *charList); + + TextOutputControl control; // formatting parameters + + UnicodeRemapping *remapping; + Unicode *uBuf; + int uBufSize; + + double pageWidth, pageHeight; // width and height of current page + int charPos; // next character position (within content + // stream) + TextFontInfo *curFont; // current font + double curFontSize; // current font size + int curRot; // current rotation + GBool diagonal; // set if rotation is not close to + // 0/90/180/270 degrees + GBool rotated; // set if text is not horizontal (0 degrees) + int nTinyChars; // number of "tiny" chars seen so far + Unicode *actualText; // current "ActualText" span + int actualTextLen; + double actualTextX0, + actualTextY0, + actualTextX1, + actualTextY1; + int actualTextNBytes; + + GList *chars; // [TextChar] + GList *fonts; // all font info objects used on this + // page [TextFontInfo] + + GList *underlines; // [TextUnderline] + GList *links; // [TextLink] + + GList *findCols; // text used by the findText**/findPoint** + // functions [TextColumn] + double lastFindXMin, // coordinates of the last "find" result + lastFindYMin; + GBool haveLastFind; + + GBool problematic; // true if any of the fonts used on this + // page are marked as problematic for + // Unicode conversion + + friend class TextOutputDev; +}; + +//------------------------------------------------------------------------ +// TextOutputDev +//------------------------------------------------------------------------ + +class TextOutputDev: public OutputDev { +public: + + // Open a text output file. If <fileName> is NULL, no file is + // written (this is useful, e.g., for searching text). If + // <physLayoutA> is true, the original physical layout of the text + // is maintained. If <rawOrder> is true, the text is kept in + // content stream order. + TextOutputDev(char *fileName, TextOutputControl *controlA, + GBool append, GBool fileNameIsUTF8 = gFalse); + + // Create a TextOutputDev which will write to a generic stream. If + // <physLayoutA> is true, the original physical layout of the text + // is maintained. If <rawOrder> is true, the text is kept in + // content stream order. + TextOutputDev(TextOutputFunc func, void *stream, + TextOutputControl *controlA); + + // Destructor. + virtual ~TextOutputDev(); + + // Check if file was successfully created. + virtual GBool isOk() { return ok; } + + //---- get info about output device + + // Does this device use upside-down coordinates? + // (Upside-down means (0,0) is the top left corner of the page.) + virtual GBool upsideDown() { return gTrue; } + + // Does this device use drawChar() or drawString()? + virtual GBool useDrawChar() { return gTrue; } + + // Does this device use beginType3Char/endType3Char? Otherwise, + // text in Type 3 fonts will be drawn with drawChar/drawString. + virtual GBool interpretType3Chars() { return gFalse; } + + // Does this device need non-text content? + virtual GBool needNonText() { return gFalse; } + + // Does this device require incCharCount to be called for text on + // non-shown layers? + virtual GBool needCharCount() { return gTrue; } + + //----- initialization and control + + // Start a page. + virtual void startPage(int pageNum, GfxState *state); + + // End a page. + virtual void endPage(); + + //----- save/restore graphics state + virtual void restoreState(GfxState *state); + + //----- update text state + virtual void updateFont(GfxState *state); + + //----- text drawing + virtual void beginString(GfxState *state, GString *s); + virtual void endString(GfxState *state); + virtual void drawChar(GfxState *state, double x, double y, + double dx, double dy, + double originX, double originY, + CharCode c, int nBytes, Unicode *u, int uLen); + virtual void incCharCount(int nChars); + virtual void beginActualText(GfxState *state, Unicode *u, int uLen); + virtual void endActualText(GfxState *state); + + //----- path painting + virtual void stroke(GfxState *state); + virtual void fill(GfxState *state); + virtual void eoFill(GfxState *state); + + //----- link borders + virtual void processLink(Link *link); + + //----- special access + + // Find a string. If <startAtTop> is true, starts looking at the + // top of the page; else if <startAtLast> is true, starts looking + // immediately after the last find result; else starts looking at + // <xMin>,<yMin>. If <stopAtBottom> is true, stops looking at the + // bottom of the page; else if <stopAtLast> is true, stops looking + // just before the last find result; else stops looking at + // <xMax>,<yMax>. + GBool findText(Unicode *s, int len, + GBool startAtTop, GBool stopAtBottom, + GBool startAtLast, GBool stopAtLast, + GBool caseSensitive, GBool backward, + GBool wholeWord, + double *xMin, double *yMin, + double *xMax, double *yMax); + + // Get the text which is inside the specified rectangle. + GString *getText(double xMin, double yMin, + double xMax, double yMax); + + // Find a string by character position and length. If found, sets + // the text bounding rectangle and returns true; otherwise returns + // false. + GBool findCharRange(int pos, int length, + double *xMin, double *yMin, + double *xMax, double *yMax); + + // Build a flat word list, in content stream order (if + // this->rawOrder is true), physical layout order (if + // this->physLayout is true and this->rawOrder is false), or reading + // order (if both flags are false). + TextWordList *makeWordList(); + + // Build a word list containing only words inside the specified + // rectangle. + TextWordList *makeWordListForRect(double xMin, double yMin, + double xMax, double yMax); + + // Returns the TextPage object for the last rasterized page, + // transferring ownership to the caller. + TextPage *takeText(); + + // Turn extra processing for HTML conversion on or off. + void enableHTMLExtras(GBool html) { control.html = html; } + +private: + + void generateBOM(); + + TextOutputFunc outputFunc; // output function + void *outputStream; // output stream + GBool needClose; // need to close the output file? + // (only if outputStream is a FILE*) + TextPage *text; // text for the current page + TextOutputControl control; // formatting parameters + GBool ok; // set up ok? +}; + +#endif |