diff options
Diffstat (limited to 'Build/source/libs/icu/icu-49.1/layoutex/layout/ParagraphLayout.h')
-rw-r--r-- | Build/source/libs/icu/icu-49.1/layoutex/layout/ParagraphLayout.h | 740 |
1 files changed, 740 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-49.1/layoutex/layout/ParagraphLayout.h b/Build/source/libs/icu/icu-49.1/layoutex/layout/ParagraphLayout.h new file mode 100644 index 00000000000..e3d58280deb --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/layoutex/layout/ParagraphLayout.h @@ -0,0 +1,740 @@ +/* + ********************************************************************** + * Copyright (C) 2002-2011, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ + +#ifndef __PARAGRAPHLAYOUT_H + +#define __PARAGRAPHLAYOUT_H + +/** + * \file + * \brief C++ API: Paragraph Layout + */ + +/* + * ParagraphLayout doesn't make much sense without + * BreakIterator... + */ +#include "unicode/uscript.h" +#if ! UCONFIG_NO_BREAK_ITERATION + +#include "layout/LETypes.h" +#include "layout/LEFontInstance.h" +#include "layout/LayoutEngine.h" +#include "unicode/ubidi.h" +#include "unicode/brkiter.h" + +#include "layout/RunArrays.h" + +U_NAMESPACE_BEGIN + +/** + * ParagraphLayout. + * + * The <code>ParagraphLayout</code> object will analyze the text into runs of text in the + * same font, script and direction, and will create a <code>LayoutEngine</code> object for each run. + * The <code>LayoutEngine</code> will transform the characters into glyph codes in visual order. + * + * Clients can use this to break a paragraph into lines, and to display the glyphs in each line. + * + */ +class U_LAYOUTEX_API ParagraphLayout : public UObject +{ +public: + class VisualRun; + + /** + * This class represents a single line of text in a <code>ParagraphLayout</code>. They + * can only be created by calling <code>ParagraphLayout::nextLine()</code>. Each line + * consists of multiple visual runs, represented by <code>ParagraphLayout::VisualRun</code> + * objects. + * + * @see ParagraphLayout + * @see ParagraphLayout::VisualRun + * + * @stable ICU 3.2 + */ + class U_LAYOUTEX_API Line : public UObject + { + public: + /** + * The constructor is private since these objects can only be + * created by <code>ParagraphLayout</code>. However, it is the + * clients responsibility to destroy the objects, so the destructor + * is public. + * + * @stable ICU 3.2 + */ + ~Line(); + + /** + * Count the number of visual runs in the line. + * + * @return the number of visual runs. + * + * @stable ICU 3.2 + */ + inline le_int32 countRuns() const; + + /** + * Get the ascent of the line. This is the maximum ascent + * of all the fonts on the line. + * + * @return the ascent of the line. + * + * @stable ICU 3.2 + */ + le_int32 getAscent() const; + + /** + * Get the descent of the line. This is the maximum descent + * of all the fonts on the line. + * + * @return the descent of the line. + * + * @stable ICU 3.2 + */ + le_int32 getDescent() const; + + /** + * Get the leading of the line. This is the maximum leading + * of all the fonts on the line. + * + * @return the leading of the line. + * + * @stable ICU 3.2 + */ + le_int32 getLeading() const; + + /** + * Get the width of the line. This is a convenience method + * which returns the last X position of the last visual run + * in the line. + * + * @return the width of the line. + * + * @stable ICU 2.8 + */ + le_int32 getWidth() const; + + /** + * Get a <code>ParagraphLayout::VisualRun</code> object for a given + * visual run in the line. + * + * @param runIndex is the index of the run, in visual order. + * + * @return the <code>ParagraphLayout::VisualRun</code> object representing the + * visual run. This object is owned by the <code>Line</code> object which + * created it, and will remain valid for as long as the <code>Line</code> + * object is valid. + * + * @see ParagraphLayout::VisualRun + * + * @stable ICU 3.2 + */ + const VisualRun *getVisualRun(le_int32 runIndex) const; + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * + * @stable ICU 3.2 + */ + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * + * @stable ICU 3.2 + */ + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + + private: + + /** + * The address of this static class variable serves as this class's ID + * for ICU "poor man's RTTI". + */ + static const char fgClassID; + + friend class ParagraphLayout; + + le_int32 fAscent; + le_int32 fDescent; + le_int32 fLeading; + + le_int32 fRunCount; + le_int32 fRunCapacity; + + VisualRun **fRuns; + + inline Line(); + inline Line(const Line &other); + inline Line &operator=(const Line & /*other*/) { return *this; }; + + void computeMetrics(); + + void append(const LEFontInstance *font, UBiDiDirection direction, le_int32 glyphCount, + const LEGlyphID glyphs[], const float positions[], const le_int32 glyphToCharMap[]); + }; + + /** + * This object represents a single visual run in a line of text in + * a paragraph. A visual run is text which is in the same font, + * script, and direction. The text is represented by an array of + * <code>LEGlyphIDs</code>, an array of (x, y) glyph positions and + * a table which maps indices into the glyph array to indices into + * the original character array which was used to create the paragraph. + * + * These objects are only created by <code>ParagraphLayout::Line</code> objects, + * so their constructors and destructors are private. + * + * @see ParagraphLayout::Line + * + * @stable ICU 3.2 + */ + class U_LAYOUTEX_API VisualRun : public UObject + { + public: + /** + * Get the <code>LEFontInstance</code> object which + * represents the font of the visual run. This will always + * be a non-composite font. + * + * @return the <code>LEFontInstance</code> object which represents the + * font of the visual run. + * + * @see LEFontInstance + * + * @stable ICU 3.2 + */ + inline const LEFontInstance *getFont() const; + + /** + * Get the direction of the visual run. + * + * @return the direction of the run. This will be UBIDI_LTR if the + * run is left-to-right and UBIDI_RTL if the line is right-to-left. + * + * @stable ICU 3.2 + */ + inline UBiDiDirection getDirection() const; + + /** + * Get the number of glyphs in the visual run. + * + * @return the number of glyphs. + * + * @stable ICU 3.2 + */ + inline le_int32 getGlyphCount() const; + + /** + * Get the glyphs in the visual run. Glyphs with the values <code>0xFFFE</code> and + * <code>0xFFFF</code> should be ignored. + * + * @return the address of the array of glyphs for this visual run. The storage + * is owned by the <code>VisualRun</code> object and must not be deleted. + * It will remain valid as long as the <code>VisualRun</code> object is valid. + * + * @stable ICU 3.2 + */ + inline const LEGlyphID *getGlyphs() const; + + /** + * Get the (x, y) positions of the glyphs in the visual run. To simplify storage + * management, the x and y positions are stored in a single array with the x positions + * at even offsets in the array and the corresponding y position in the following odd offset. + * There is an extra (x, y) pair at the end of the array which represents the advance of + * the final glyph in the run. + * + * @return the address of the array of glyph positions for this visual run. The storage + * is owned by the <code>VisualRun</code> object and must not be deleted. + * It will remain valid as long as the <code>VisualRun</code> object is valid. + * + * @stable ICU 3.2 + */ + inline const float *getPositions() const; + + /** + * Get the glyph-to-character map for this visual run. This maps the indices into + * the glyph array to indices into the character array used to create the paragraph. + * + * @return the address of the character-to-glyph map for this visual run. The storage + * is owned by the <code>VisualRun</code> object and must not be deleted. + * It will remain valid as long as the <code>VisualRun</code> object is valid. + * + * @stable ICU 3.2 + */ + inline const le_int32 *getGlyphToCharMap() const; + + /** + * A convenience method which returns the ascent value for the font + * associated with this run. + * + * @return the ascent value of this run's font. + * + * @stable ICU 3.2 + */ + inline le_int32 getAscent() const; + + /** + * A convenience method which returns the descent value for the font + * associated with this run. + * + * @return the descent value of this run's font. + * + * @stable ICU 3.2 + */ + inline le_int32 getDescent() const; + + /** + * A convenience method which returns the leading value for the font + * associated with this run. + * + * @return the leading value of this run's font. + * + * @stable ICU 3.2 + */ + inline le_int32 getLeading() const; + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * + * @stable ICU 3.2 + */ + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * + * @stable ICU 3.2 + */ + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + + private: + + /** + * The address of this static class variable serves as this class's ID + * for ICU "poor man's RTTI". + */ + static const char fgClassID; + + const LEFontInstance *fFont; + const UBiDiDirection fDirection; + + const le_int32 fGlyphCount; + + const LEGlyphID *fGlyphs; + const float *fPositions; + const le_int32 *fGlyphToCharMap; + + friend class Line; + + inline VisualRun(); + inline VisualRun(const VisualRun &other); + inline VisualRun &operator=(const VisualRun &/*other*/) { return *this; }; + + inline VisualRun(const LEFontInstance *font, UBiDiDirection direction, le_int32 glyphCount, + const LEGlyphID glyphs[], const float positions[], const le_int32 glyphToCharMap[]); + + ~VisualRun(); + }; + + /** + * Construct a <code>ParagraphLayout</code> object for a styled paragraph. The paragraph is specified + * as runs of text all in the same font. An <code>LEFontInstance</code> object and a limit offset + * are specified for each font run. The limit offset is the offset of the character immediately + * after the font run. + * + * Clients can optionally specify directional runs and / or script runs. If these aren't specified + * they will be computed. + * + * If any errors are encountered during construction, <code>status</code> will be set, and the object + * will be set to be empty. + * + * @param chars is an array of the characters in the paragraph + * + * @param count is the number of characters in the paragraph. + * + * @param fontRuns a pointer to a <code>FontRuns</code> object representing the font runs. + * + * @param levelRuns is a pointer to a <code>ValueRuns</code> object representing the directional levels. + * If this pointer in <code>NULL</code> the levels will be determined by running the Unicde + * Bidi algorithm. + * + * @param scriptRuns is a pointer to a <code>ValueRuns</code> object representing script runs. + * If this pointer in <code>NULL</code> the script runs will be determined using the + * Unicode code points. + * + * @param localeRuns is a pointer to a <code>LocaleRuns</code> object representing locale runs. + * The <code>Locale</code> objects are used to determind the language of the text. If this + * pointer is <code>NULL</code> the default locale will be used for all of the text. + * + * @param paragraphLevel is the directionality of the paragraph, as in the UBiDi object. + * + * @param vertical is <code>TRUE</code> if the paragraph should be set vertically. + * + * @param status will be set to any error code encountered during construction. + * + * @see ubidi.h + * @see LEFontInstance.h + * @see LayoutEngine.h + * @see RunArrays.h + * + * @stable ICU 2.8 + */ + ParagraphLayout(const LEUnicode chars[], le_int32 count, + const FontRuns *fontRuns, + const ValueRuns *levelRuns, + const ValueRuns *scriptRuns, + const LocaleRuns *localeRuns, + UBiDiLevel paragraphLevel, le_bool vertical, + LEErrorCode &status); + + /** + * The destructor. Virtual so that it works correctly with + * sublcasses. + * + * @stable ICU 3.2 + */ + ~ParagraphLayout(); + + // Note: the following is #if 0'd out because there's no good + // way to implement it without either calling layoutEngineFactory() + // or duplicating the logic there... +#if 0 + /** + * Examine the given styled paragraph and determine if it contains any text which + * requires complex processing. (i.e. that cannot be correctly rendered by + * just mapping the characters to glyphs and rendering them in order) + * + * @param chars is an array of the characters in the paragraph + * + * @param count is the number of characters in the paragraph. + * + * @param fontRuns is a pointer to a <code>FontRuns</code> object representing the font runs. + * + * @return <code>TRUE</code> if the paragraph contains complex text. + * + * @stable ICU 3.2 + */ + static le_bool isComplex(const LEUnicode chars[], le_int32 count, const FontRuns *fontRuns); +#else + /** + * Examine the given text and determine if it contains characters in any + * script which requires complex processing to be rendered correctly. + * + * @param chars is an array of the characters in the paragraph + * + * @param count is the number of characters in the paragraph. + * + * @return <code>TRUE</code> if any of the text requires complex processing. + * + * @stable ICU 3.2 + */ + static le_bool isComplex(const LEUnicode chars[], le_int32 count); + +#endif + + /** + * Return the resolved paragraph level. This is useful for those cases + * where the bidi analysis has determined the level based on the first + * strong character in the paragraph. + * + * @return the resolved paragraph level. + * + * @stable ICU 3.2 + */ + inline UBiDiLevel getParagraphLevel(); + + /** + * Return the directionality of the text in the paragraph. + * + * @return <code>UBIDI_LTR</code> if the text is all left to right, + * <code>UBIDI_RTL</code> if the text is all right to left, + * or <code>UBIDI_MIXED</code> if the text has mixed direction. + * + * @stable ICU 3.2 + */ + inline UBiDiDirection getTextDirection(); + + /** + * Return the max ascent value for all the fonts + * in the paragraph. + * + * @return the ascent value. + * + * @stable ICU 3.2 + */ + virtual le_int32 getAscent() const; + + /** + * Return the max descent value for all the fonts + * in the paragraph. + * + * @return the decent value. + * + * @stable ICU 3.2 + */ + virtual le_int32 getDescent() const; + + /** + * Return the max leading value for all the fonts + * in the paragraph. + * + * @return the leading value. + * + * @stable ICU 3.2 + */ + virtual le_int32 getLeading() const; + + /** + * Reset line breaking to start from the beginning of the paragraph. + * + * + * @stable ICU 3.2 + */ + inline void reflow(); + +#ifndef U_HIDE_INTERNAL_API + /** + * + * Convenience method for determining if paragraph layout processing is complete ( i.e. there + * are no more lines left to process. ) + * + * @return true if there are no more lines to be processed + * + * @internal + */ + inline le_bool isDone() const; +#endif /* U_HIDE_INTERNAL_API */ + + /** + * Return a <code>ParagraphLayout::Line</code> object which represents next line + * in the paragraph. The width of the line is specified each time so that it can + * be varied to support arbitrary paragraph shapes. + * + * @param width is the width of the line. If <code>width</code> is less than or equal + * to zero, a <code>ParagraphLayout::Line</code> object representing the + * rest of the paragraph will be returned. + * + * @return a <code>ParagraphLayout::Line</code> object which represents the line. The caller + * is responsible for deleting the object. Returns <code>NULL</code> if there are no + * more lines in the paragraph. + * + * @see ParagraphLayout::Line + * + * @stable ICU 3.2 + */ + Line *nextLine(float width); + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * + * @stable ICU 3.2 + */ + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * + * @stable ICU 3.2 + */ + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + +private: + + + /** + * The address of this static class variable serves as this class's ID + * for ICU "poor man's RTTI". + */ + static const char fgClassID; + + struct StyleRunInfo + { + LayoutEngine *engine; + const LEFontInstance *font; + const Locale *locale; + LEGlyphID *glyphs; + float *positions; + UScriptCode script; + UBiDiLevel level; + le_int32 runBase; + le_int32 runLimit; + le_int32 glyphBase; + le_int32 glyphCount; + }; + + ParagraphLayout() {}; + ParagraphLayout(const ParagraphLayout & /*other*/) : UObject( ){}; + inline ParagraphLayout &operator=(const ParagraphLayout & /*other*/) { return *this; }; + + void computeLevels(UBiDiLevel paragraphLevel); + + Line *computeVisualRuns(); + void appendRun(Line *line, le_int32 run, le_int32 firstChar, le_int32 lastChar); + + void computeScripts(); + + void computeLocales(); + + void computeSubFonts(const FontRuns *fontRuns, LEErrorCode &status); + + void computeMetrics(); + + le_int32 getLanguageCode(const Locale *locale); + + le_int32 getCharRun(le_int32 charIndex); + + static le_bool isComplex(UScriptCode script); + + le_int32 previousBreak(le_int32 charIndex); + + + const LEUnicode *fChars; + le_int32 fCharCount; + + const FontRuns *fFontRuns; + const ValueRuns *fLevelRuns; + const ValueRuns *fScriptRuns; + const LocaleRuns *fLocaleRuns; + + le_bool fVertical; + le_bool fClientLevels; + le_bool fClientScripts; + le_bool fClientLocales; + + UBiDiLevel *fEmbeddingLevels; + + le_int32 fAscent; + le_int32 fDescent; + le_int32 fLeading; + + le_int32 *fGlyphToCharMap; + le_int32 *fCharToMinGlyphMap; + le_int32 *fCharToMaxGlyphMap; + float *fGlyphWidths; + le_int32 fGlyphCount; + + UBiDi *fParaBidi; + UBiDi *fLineBidi; + + le_int32 *fStyleRunLimits; + le_int32 *fStyleIndices; + StyleRunInfo *fStyleRunInfo; + le_int32 fStyleRunCount; + + BreakIterator *fBreakIterator; + le_int32 fLineStart; + le_int32 fLineEnd; + + le_int32 fFirstVisualRun; + le_int32 fLastVisualRun; + float fVisualRunLastX; + float fVisualRunLastY; +}; + +inline UBiDiLevel ParagraphLayout::getParagraphLevel() +{ + return ubidi_getParaLevel(fParaBidi); +} + +inline UBiDiDirection ParagraphLayout::getTextDirection() +{ + return ubidi_getDirection(fParaBidi); +} + +inline void ParagraphLayout::reflow() +{ + fLineEnd = 0; +} + +inline ParagraphLayout::Line::Line() + : UObject(), fAscent(0), fDescent(0), fLeading(0), fRunCount(0), fRunCapacity(0), fRuns(NULL) +{ + // nothing else to do +} + +inline ParagraphLayout::Line::Line(const Line & /*other*/) + : UObject(), fAscent(0), fDescent(0), fLeading(0), fRunCount(0), fRunCapacity(0), fRuns(NULL) +{ + // nothing else to do +} + +inline le_int32 ParagraphLayout::Line::countRuns() const +{ + return fRunCount; +} + +inline const LEFontInstance *ParagraphLayout::VisualRun::getFont() const +{ + return fFont; +} + +inline UBiDiDirection ParagraphLayout::VisualRun::getDirection() const +{ + return fDirection; +} + +inline le_int32 ParagraphLayout::VisualRun::getGlyphCount() const +{ + return fGlyphCount; +} + +inline const LEGlyphID *ParagraphLayout::VisualRun::getGlyphs() const +{ + return fGlyphs; +} + +inline const float *ParagraphLayout::VisualRun::getPositions() const +{ + return fPositions; +} + +inline const le_int32 *ParagraphLayout::VisualRun::getGlyphToCharMap() const +{ + return fGlyphToCharMap; +} + +inline le_int32 ParagraphLayout::VisualRun::getAscent() const +{ + return fFont->getAscent(); +} + +inline le_int32 ParagraphLayout::VisualRun::getDescent() const +{ + return fFont->getDescent(); +} + +inline le_int32 ParagraphLayout::VisualRun::getLeading() const +{ + return fFont->getLeading(); +} + +inline ParagraphLayout::VisualRun::VisualRun() + : UObject(), fFont(NULL), fDirection(UBIDI_LTR), fGlyphCount(0), fGlyphs(NULL), fPositions(NULL), fGlyphToCharMap(NULL) +{ + // nothing +} + +inline ParagraphLayout::VisualRun::VisualRun(const VisualRun &/*other*/) + : UObject(), fFont(NULL), fDirection(UBIDI_LTR), fGlyphCount(0), fGlyphs(NULL), fPositions(NULL), fGlyphToCharMap(NULL) +{ + // nothing +} + +inline ParagraphLayout::VisualRun::VisualRun(const LEFontInstance *font, UBiDiDirection direction, le_int32 glyphCount, + const LEGlyphID glyphs[], const float positions[], const le_int32 glyphToCharMap[]) + : fFont(font), fDirection(direction), fGlyphCount(glyphCount), + fGlyphs(glyphs), fPositions(positions), fGlyphToCharMap(glyphToCharMap) +{ + // nothing else needs to be done! +} + +U_NAMESPACE_END +#endif +#endif |