/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/text/bidirectional-line-info-run.h>
+#include <dali-toolkit/internal/text/bidirectional-support.h>
#include <dali-toolkit/internal/text/cursor-helper-functions.h>
#include <dali-toolkit/internal/text/glyph-metrics-helper.h>
#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
const float MAX_FLOAT = std::numeric_limits<float>::max();
const CharacterDirection LTR = false;
const CharacterDirection RTL = !LTR;
-const float LINE_SPACING= 0.f;
+const float LINE_SPACING = 0.f;
+const float MIN_LINE_SIZE = 0.f;
inline bool isEmptyLineAtLast( const Vector<LineRun>& lines, const Vector<LineRun>::Iterator& line )
{
struct LineLayout
{
LineLayout()
- : glyphIndex( 0u ),
- characterIndex( 0u ),
- numberOfGlyphs( 0u ),
- numberOfCharacters( 0u ),
- ascender( -MAX_FLOAT ),
- descender( MAX_FLOAT ),
- lineSpacing( 0.f ),
- penX( 0.f ),
- previousAdvance( 0.f ),
- length( 0.f ),
- wsLengthEndOfLine( 0.f )
+ : glyphIndex{ 0u },
+ characterIndex{ 0u },
+ numberOfGlyphs{ 0u },
+ numberOfCharacters{ 0u },
+ ascender{ -MAX_FLOAT },
+ descender{ MAX_FLOAT },
+ lineSpacing{ 0.f },
+ penX{ 0.f },
+ previousAdvance{ 0.f },
+ length{ 0.f },
+ whiteSpaceLengthEndOfLine{ 0.f },
+ direction{ LTR }
{}
~LineLayout()
characterIndex = 0u;
numberOfGlyphs = 0u;
numberOfCharacters = 0u;
- ascender = 0.f;
+ ascender = -MAX_FLOAT;
descender = MAX_FLOAT;
+ direction = LTR;
}
- GlyphIndex glyphIndex; ///< Index of the first glyph to be laid-out.
- CharacterIndex characterIndex; ///< Index of the first character to be laid-out.
- Length numberOfGlyphs; ///< The number of glyph which fit in one line.
- Length numberOfCharacters; ///< The number of characters which fit in one line.
- float ascender; ///< The maximum ascender of all fonts in the line.
- float descender; ///< The minimum descender of all fonts in the line.
- float lineSpacing; ///< The line spacing
- float penX; ///< The origin of the current glyph ( is the start point plus the accumulation of all advances ).
- float previousAdvance; ///< The advance of the previous glyph.
- float length; ///< The current length of the line.
- float wsLengthEndOfLine; ///< The length of the white spaces at the end of the line.
+ GlyphIndex glyphIndex; ///< Index of the first glyph to be laid-out.
+ CharacterIndex characterIndex; ///< Index of the first character to be laid-out.
+ Length numberOfGlyphs; ///< The number of glyph which fit in one line.
+ Length numberOfCharacters; ///< The number of characters which fit in one line.
+ float ascender; ///< The maximum ascender of all fonts in the line.
+ float descender; ///< The minimum descender of all fonts in the line.
+ float lineSpacing; ///< The line spacing
+ float penX; ///< The origin of the current glyph ( is the start point plus the accumulation of all advances ).
+ float previousAdvance; ///< The advance of the previous glyph.
+ float length; ///< The current length of the line.
+ float whiteSpaceLengthEndOfLine; ///< The length of the white spaces at the end of the line.
+ CharacterDirection direction;
+};
+
+struct LayoutBidiParameters
+{
+ void Clear()
+ {
+ paragraphDirection = LTR;
+ bidiParagraphIndex = 0u;
+ bidiLineIndex = 0u;
+ isBidirectional = false;
+ }
+
+ CharacterDirection paragraphDirection = LTR; ///< The paragraph's direction.
+ BidirectionalRunIndex bidiParagraphIndex = 0u; ///< Index to the paragraph's bidi info.
+ BidirectionalLineRunIndex bidiLineIndex = 0u; ///< Index where to insert the next bidi line info.
+ bool isBidirectional = false; ///< Whether the text is bidirectional.
};
struct Engine::Impl
{
Impl()
- : mLayout( Layout::Engine::SINGLE_LINE_BOX ),
- mCursorWidth( 0.f ),
- mDefaultLineSpacing( LINE_SPACING )
+ : mLayout{ Layout::Engine::SINGLE_LINE_BOX },
+ mCursorWidth{ 0.f },
+ mDefaultLineSpacing{ LINE_SPACING },
+ mDefaultLineSize{ MIN_LINE_SIZE }
{
}
// Sets the minimum descender.
lineLayout.descender = std::min( lineLayout.descender, fontMetrics.descender );
- // set the line spacing
- lineLayout.lineSpacing = mDefaultLineSpacing;
+ // Sets the line size
+ lineLayout.lineSpacing = mDefaultLineSize - ( lineLayout.ascender + -lineLayout.descender );
+ lineLayout.lineSpacing = lineLayout.lineSpacing < 0.f ? 0.f : lineLayout.lineSpacing;
+
+ // Add the line spacing
+ lineLayout.lineSpacing += mDefaultLineSpacing;
}
/**
lineLayout.previousAdvance = tmpLineLayout.previousAdvance;
lineLayout.length = tmpLineLayout.length;
- lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
+ lineLayout.whiteSpaceLengthEndOfLine = tmpLineLayout.whiteSpaceLengthEndOfLine;
// Sets the maximum ascender.
lineLayout.ascender = std::max( lineLayout.ascender, tmpLineLayout.ascender );
lineLayout.descender = std::min( lineLayout.descender, tmpLineLayout.descender );
}
+ void LayoutRightToLeft( const Parameters& parameters,
+ const BidirectionalLineInfoRun& bidirectionalLineInfo,
+ float& length,
+ float& whiteSpaceLengthEndOfLine )
+ {
+ const Character* const textBuffer = parameters.textModel->mLogicalModel->mText.Begin();
+ const Length* const charactersPerGlyphBuffer = parameters.textModel->mVisualModel->mCharactersPerGlyph.Begin();
+ const GlyphInfo* const glyphsBuffer = parameters.textModel->mVisualModel->mGlyphs.Begin();
+ const GlyphIndex* const charactersToGlyphsBuffer = parameters.textModel->mVisualModel->mCharactersToGlyph.Begin();
+
+ const float outlineWidth = static_cast<float>( parameters.textModel->GetOutlineWidth() );
+ const GlyphIndex lastGlyphOfParagraphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs;
+
+ CharacterIndex characterLogicalIndex = 0u;
+ CharacterIndex characterVisualIndex = bidirectionalLineInfo.characterRun.characterIndex + *( bidirectionalLineInfo.visualToLogicalMap + characterLogicalIndex );
+
+ if( RTL == bidirectionalLineInfo.direction )
+ {
+ while( TextAbstraction::IsWhiteSpace( *( textBuffer + characterVisualIndex ) ) )
+ {
+ const GlyphInfo& glyphInfo = *( glyphsBuffer + *( charactersToGlyphsBuffer + characterVisualIndex ) );
+
+ whiteSpaceLengthEndOfLine += glyphInfo.advance;
+
+ ++characterLogicalIndex;
+ characterVisualIndex = bidirectionalLineInfo.characterRun.characterIndex + *( bidirectionalLineInfo.visualToLogicalMap + characterLogicalIndex );
+ }
+ }
+
+ const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex );
+
+ // Check whether the first glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ charactersPerGlyphBuffer );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ glyphsBuffer,
+ mMetrics );
+
+ float penX = -glyphMetrics.xBearing + mCursorWidth + outlineWidth;
+
+ // Traverses the characters of the right to left paragraph.
+ for( ; characterLogicalIndex < bidirectionalLineInfo.characterRun.numberOfCharacters; )
+ {
+ // Convert the character in the logical order into the character in the visual order.
+ const CharacterIndex characterVisualIndex = bidirectionalLineInfo.characterRun.characterIndex + *( bidirectionalLineInfo.visualToLogicalMap + characterLogicalIndex );
+ const bool isWhiteSpace = TextAbstraction::IsWhiteSpace( *( textBuffer + characterVisualIndex ) );
+
+ const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex );
+
+ // Check whether this glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ charactersPerGlyphBuffer );
+
+ characterLogicalIndex += *( charactersPerGlyphBuffer + glyphIndex + numberOfGLyphsInGroup - 1u );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ glyphsBuffer,
+ mMetrics );
+
+ if( isWhiteSpace )
+ {
+ if( RTL == bidirectionalLineInfo.direction )
+ {
+ length += glyphMetrics.advance;
+ }
+ else
+ {
+ whiteSpaceLengthEndOfLine += glyphMetrics.advance;
+ }
+ penX += glyphMetrics.advance;
+ }
+ else
+ {
+ if( LTR == bidirectionalLineInfo.direction )
+ {
+ whiteSpaceLengthEndOfLine = 0.f;
+ }
+ length = std::max( length, penX + glyphMetrics.xBearing + glyphMetrics.width );
+ penX += ( glyphMetrics.advance + parameters.interGlyphExtraAdvance );
+ }
+ }
+ }
+
+ void ReorderBiDiLayout( const Parameters& parameters,
+ LayoutBidiParameters& bidiParameters,
+ const LineLayout& currentLineLayout,
+ LineLayout& lineLayout,
+ bool breakInCharacters )
+ {
+ const Length* const charactersPerGlyphBuffer = parameters.textModel->mVisualModel->mCharactersPerGlyph.Begin();
+
+ // The last glyph to be laid-out.
+ const GlyphIndex lastGlyphOfParagraphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs;
+
+ const Vector<BidirectionalParagraphInfoRun>& bidirectionalParagraphsInfo = parameters.textModel->mLogicalModel->mBidirectionalParagraphInfo;
+
+ const BidirectionalParagraphInfoRun& bidirectionalParagraphInfo = bidirectionalParagraphsInfo[bidiParameters.bidiParagraphIndex];
+ if( ( lineLayout.characterIndex >= bidirectionalParagraphInfo.characterRun.characterIndex ) &&
+ ( lineLayout.characterIndex < bidirectionalParagraphInfo.characterRun.characterIndex + bidirectionalParagraphInfo.characterRun.numberOfCharacters ) )
+ {
+ Vector<BidirectionalLineInfoRun>& bidirectionalLinesInfo = parameters.textModel->mLogicalModel->mBidirectionalLineInfo;
+
+ // Sets the visual to logical map tables needed to reorder the text.
+ ReorderLine( bidirectionalParagraphInfo,
+ bidirectionalLinesInfo,
+ bidiParameters.bidiLineIndex,
+ lineLayout.characterIndex,
+ lineLayout.numberOfCharacters,
+ bidiParameters.paragraphDirection );
+
+ // Recalculate the length of the line and update the layout.
+ const BidirectionalLineInfoRun& bidirectionalLineInfo = *( bidirectionalLinesInfo.Begin() + bidiParameters.bidiLineIndex );
+
+ if( !bidirectionalLineInfo.isIdentity )
+ {
+ float length = 0.f;
+ float whiteSpaceLengthEndOfLine = 0.f;
+ LayoutRightToLeft( parameters,
+ bidirectionalLineInfo,
+ length,
+ whiteSpaceLengthEndOfLine );
+
+ lineLayout.whiteSpaceLengthEndOfLine = whiteSpaceLengthEndOfLine;
+ if( !Equals( length, lineLayout.length ) )
+ {
+ const bool isMultiline = mLayout == MULTI_LINE_BOX;
+
+ if( isMultiline && ( length > parameters.boundingBox.width ) )
+ {
+ if( breakInCharacters || ( isMultiline && ( 0u == currentLineLayout.numberOfGlyphs ) ) )
+ {
+ // The word doesn't fit in one line. It has to be split by character.
+
+ // Remove the last laid out glyph(s) as they doesn't fit.
+ for( GlyphIndex glyphIndex = lineLayout.glyphIndex + lineLayout.numberOfGlyphs - 1u; glyphIndex >= lineLayout.glyphIndex; )
+ {
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ charactersPerGlyphBuffer );
+
+ const Length numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex + numberOfGLyphsInGroup - 1u );
+
+ lineLayout.numberOfGlyphs -= numberOfGLyphsInGroup;
+ lineLayout.numberOfCharacters -= numberOfCharacters;
+
+ AdjustLayout( parameters,
+ bidiParameters,
+ bidirectionalParagraphInfo,
+ lineLayout );
+
+ if( lineLayout.length < parameters.boundingBox.width )
+ {
+ break;
+ }
+
+ if( glyphIndex < numberOfGLyphsInGroup )
+ {
+ // avoids go under zero for an unsigned int.
+ break;
+ }
+
+ glyphIndex -= numberOfGLyphsInGroup;
+ }
+ }
+ else
+ {
+ lineLayout = currentLineLayout;
+
+ AdjustLayout( parameters,
+ bidiParameters,
+ bidirectionalParagraphInfo,
+ lineLayout );
+ }
+ }
+ else
+ {
+ lineLayout.length = std::max( length, lineLayout.length );
+ }
+ }
+ }
+ }
+ }
+
+ void AdjustLayout( const Parameters& parameters,
+ LayoutBidiParameters& bidiParameters,
+ const BidirectionalParagraphInfoRun& bidirectionalParagraphInfo,
+ LineLayout& lineLayout )
+ {
+ Vector<BidirectionalLineInfoRun>& bidirectionalLinesInfo = parameters.textModel->mLogicalModel->mBidirectionalLineInfo;
+
+ // Remove current reordered line.
+ bidirectionalLinesInfo.Erase( bidirectionalLinesInfo.Begin() + bidiParameters.bidiLineIndex );
+
+ // Re-build the conversion table without the removed glyphs.
+ ReorderLine( bidirectionalParagraphInfo,
+ bidirectionalLinesInfo,
+ bidiParameters.bidiLineIndex,
+ lineLayout.characterIndex,
+ lineLayout.numberOfCharacters,
+ bidiParameters.paragraphDirection );
+
+ const BidirectionalLineInfoRun& bidirectionalLineInfo = *( bidirectionalLinesInfo.Begin() + bidiParameters.bidiLineIndex );
+
+ float length = 0.f;
+ float whiteSpaceLengthEndOfLine = 0.f;
+ LayoutRightToLeft( parameters,
+ bidirectionalLineInfo,
+ length,
+ whiteSpaceLengthEndOfLine );
+
+ lineLayout.length = length;
+ lineLayout.whiteSpaceLengthEndOfLine = whiteSpaceLengthEndOfLine;
+ }
+
/**
* Retrieves the line layout for a given box width.
*
- * @note This method lais out text as it were left to right. At this point is not possible to reorder the line
- * because the number of characters of the line is not known (one of the responsabilities of this method
- * is calculate that). Due to glyph's 'x' bearing, width and advance, when right to left or mixed right to left
- * and left to right text is laid-out, it can be small differences in the line length. One solution is to
- * reorder and re-lay out the text after this method and add or remove one extra glyph if needed. However,
- * this method calculates which are the first and last glyphs of the line (the ones that causes the
- * differences). This is a good point to check if there is problems with the text exceeding the boundaries
- * of the control when there is right to left text.
+ * @note This method starts to layout text as if it was left to right. However, it might be differences in the length
+ * of the line if it's a bidirectional one. If the paragraph is bidirectional, this method will call a function
+ * to reorder the line and recalculate its length.
*
+
* @param[in] parameters The layout parameters.
+ * @param[] bidiParameters Bidirectional info for the current line.
* @param[out] lineLayout The line layout.
- * @param[in,out] paragraphDirection in: the current paragraph's direction, out: the next paragraph's direction. Is set after a must break.
* @param[in] completelyFill Whether to completely fill the line ( even if the last word exceeds the boundaries ).
*/
void GetLineLayoutForBox( const Parameters& parameters,
+ LayoutBidiParameters& bidiParameters,
LineLayout& lineLayout,
- CharacterDirection& paragraphDirection,
bool completelyFill )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->GetLineLayoutForBox\n" );
const CharacterIndex* const glyphsToCharactersBuffer = parameters.textModel->mVisualModel->mGlyphsToCharacters.Begin();
const LineBreakInfo* const lineBreakInfoBuffer = parameters.textModel->mLogicalModel->mLineBreakInfo.Begin();
- const bool hasBidiParagraphs = !parameters.textModel->mLogicalModel->mBidirectionalParagraphInfo.Empty();
- const CharacterDirection* const characterDirectionBuffer = hasBidiParagraphs ? parameters.textModel->mLogicalModel->mCharacterDirections.Begin() : nullptr;
-
const float outlineWidth = static_cast<float>( parameters.textModel->GetOutlineWidth() );
const Length totalNumberOfGlyphs = parameters.textModel->mVisualModel->mGlyphs.Count();
// It needs to add as well space for the cursor if the text is in edit mode and extra space in case the text is outlined.
tmpLineLayout.penX = -glyphMetrics.xBearing + mCursorWidth + outlineWidth;
- // Initialize the advance of the previous glyph.
- tmpLineLayout.previousAdvance = 0.f;
-
// Calculate the line height if there is no characters.
FontId lastFontId = glyphMetrics.fontId;
UpdateLineHeight( glyphMetrics, tmpLineLayout );
const float previousTmpPenX = tmpLineLayout.penX;
const float previousTmpAdvance = tmpLineLayout.previousAdvance;
const float previousTmpLength = tmpLineLayout.length;
- const float previousTmpWsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
+ const float previousTmpWhiteSpaceLengthEndOfLine = tmpLineLayout.whiteSpaceLengthEndOfLine;
if( isWhiteSpace )
{
// Add the length to the length of white spaces at the end of the line.
- tmpLineLayout.wsLengthEndOfLine += glyphMetrics.advance; // The advance is used as the width is always zero for the white spaces.
+ tmpLineLayout.whiteSpaceLengthEndOfLine += glyphMetrics.advance; // The advance is used as the width is always zero for the white spaces.
}
else
{
- tmpLineLayout.penX += tmpLineLayout.previousAdvance + tmpLineLayout.wsLengthEndOfLine;
+ tmpLineLayout.penX += tmpLineLayout.previousAdvance + tmpLineLayout.whiteSpaceLengthEndOfLine;
tmpLineLayout.previousAdvance = ( glyphMetrics.advance + parameters.interGlyphExtraAdvance );
- tmpLineLayout.length = tmpLineLayout.penX + glyphMetrics.xBearing + glyphMetrics.width;
+
+ tmpLineLayout.length = std::max( tmpLineLayout.length, tmpLineLayout.penX + glyphMetrics.xBearing + glyphMetrics.width );
// Clear the white space length at the end of the line.
- tmpLineLayout.wsLengthEndOfLine = 0.f;
+ tmpLineLayout.whiteSpaceLengthEndOfLine = 0.f;
}
// Check if the accumulated length fits in the width of the box.
tmpLineLayout.penX = previousTmpPenX;
tmpLineLayout.previousAdvance = previousTmpAdvance;
tmpLineLayout.length = previousTmpLength;
- tmpLineLayout.wsLengthEndOfLine = previousTmpWsLengthEndOfLine;
+ tmpLineLayout.whiteSpaceLengthEndOfLine = previousTmpWhiteSpaceLengthEndOfLine;
}
// Add part of the word to the line layout.
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox.\n" );
+ // Reorder the RTL line.
+ if( bidiParameters.isBidirectional )
+ {
+ ReorderBiDiLayout( parameters,
+ bidiParameters,
+ lineLayout,
+ lineLayout,
+ true );
+ }
+
return;
}
if( ( isMultiline || isLastGlyph ) &&
( TextAbstraction::LINE_MUST_BREAK == lineBreakInfo ) )
{
+ LineLayout currentLineLayout = lineLayout;
+
// Must break the line. Update the line layout and return.
MergeLineLayout( lineLayout, tmpLineLayout );
- // Set the next paragraph's direction.
- if( !isLastGlyph &&
- ( nullptr != characterDirectionBuffer ) )
+ // Reorder the RTL line.
+ if( bidiParameters.isBidirectional )
{
- paragraphDirection = *( characterDirectionBuffer + 1u + characterLastIndex );
+ ReorderBiDiLayout( parameters,
+ bidiParameters,
+ currentLineLayout,
+ lineLayout,
+ false );
}
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" );
const GlyphInfo& glyph = *( glyphsBuffer + i );
Vector2& position = *( glyphPositionsBuffer + i );
- position.x = std::roundf( penX + glyph.xBearing );
+ position.x = penX + glyph.xBearing;
position.y = -glyph.yBearing;
penX += ( glyph.advance + interGlyphExtraAdvance );
}
}
+ void SetGlyphPositions( const Parameters& layoutParameters,
+ Vector2* glyphPositionsBuffer,
+ LayoutBidiParameters& layoutBidiParameters,
+ const LineLayout& layout )
+ {
+ const Character* const textBuffer = layoutParameters.textModel->mLogicalModel->mText.Begin();
+ const BidirectionalLineInfoRun& bidiLine = layoutParameters.textModel->mLogicalModel->mBidirectionalLineInfo[layoutBidiParameters.bidiLineIndex];
+ const GlyphInfo* const glyphsBuffer = layoutParameters.textModel->mVisualModel->mGlyphs.Begin();
+ const GlyphIndex* const charactersToGlyphsBuffer = layoutParameters.textModel->mVisualModel->mCharactersToGlyph.Begin();
+ const Length* const glyphsPerCharacterBuffer = layoutParameters.textModel->mVisualModel->mGlyphsPerCharacter.Begin();
+
+ CharacterIndex characterLogicalIndex = 0u;
+ CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
+
+ float penX = 0.f;
+ while( TextAbstraction::IsWhiteSpace( *( textBuffer + characterVisualIndex ) ) )
+ {
+ const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex );
+ const GlyphInfo& glyph = *( glyphsBuffer + glyphIndex );
+
+ Vector2& position = *( glyphPositionsBuffer + glyphIndex - layoutParameters.startGlyphIndex );
+ position.x = penX;
+ position.y = -glyph.yBearing;
+
+ penX += glyph.advance;
+
+ ++characterLogicalIndex;
+ characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
+ }
+
+ const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex );
+ const GlyphInfo& glyph = *( glyphsBuffer + glyphIndex );
+
+ penX += -glyph.xBearing;
+
+ // Traverses the characters of the right to left paragraph.
+ for( ; characterLogicalIndex < bidiLine.characterRun.numberOfCharacters;
+ ++characterLogicalIndex )
+ {
+ // Convert the character in the logical order into the character in the visual order.
+ const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
+
+ // Get the number of glyphs of the character.
+ const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterVisualIndex );
+
+ for( GlyphIndex index = 0u; index < numberOfGlyphs; ++index )
+ {
+ // Convert the character in the visual order into the glyph in the visual order.
+ const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex ) + index;
+
+ DALI_ASSERT_DEBUG( glyphIndex < layoutParameters.textModel->mVisualModel->mGlyphs.Count() );
+
+ const GlyphInfo& glyph = *( glyphsBuffer + glyphIndex );
+ Vector2& position = *( glyphPositionsBuffer + glyphIndex - layoutParameters.startGlyphIndex );
+
+ position.x = penX + glyph.xBearing;
+ position.y = -glyph.yBearing;
+
+ penX += ( glyph.advance + layoutParameters.interGlyphExtraAdvance );
+ }
+ }
+ }
+
/**
* @brief Resizes the line buffer.
*
* return Whether the line is ellipsized.
*/
bool EllipsisLine( const Parameters& layoutParameters,
+ LayoutBidiParameters& layoutBidiParameters,
const LineLayout& layout,
Size& layoutSize,
LineRun* linesBuffer,
Vector2* glyphPositionsBuffer,
Length& numberOfLines,
float penY,
- CharacterDirection currentParagraphDirection,
bool& isAutoScrollEnabled )
{
const bool ellipsis = isAutoScrollEnabled ? ( penY - layout.descender > layoutParameters.boundingBox.height ) :
}
GetLineLayoutForBox( layoutParameters,
+ layoutBidiParameters,
ellipsisLayout,
- currentParagraphDirection,
true );
lineRun->glyphRun.numberOfGlyphs = ellipsisLayout.numberOfGlyphs;
lineRun->characterRun.characterIndex = ellipsisLayout.characterIndex;
lineRun->characterRun.numberOfCharacters = ellipsisLayout.numberOfCharacters;
lineRun->width = ellipsisLayout.length;
- lineRun->extraLength = std::ceil( ellipsisLayout.wsLengthEndOfLine );
+ lineRun->extraLength = std::ceil( ellipsisLayout.whiteSpaceLengthEndOfLine );
lineRun->ascender = ellipsisLayout.ascender;
lineRun->descender = ellipsisLayout.descender;
- lineRun->direction = LTR;
lineRun->ellipsis = true;
layoutSize.width = layoutParameters.boundingBox.width;
const GlyphInfo* const glyphsBuffer = layoutParameters.textModel->mVisualModel->mGlyphs.Begin();
const float outlineWidth = static_cast<float>( layoutParameters.textModel->GetOutlineWidth() );
- SetGlyphPositions( glyphsBuffer + lineRun->glyphRun.glyphIndex,
- ellipsisLayout.numberOfGlyphs,
- outlineWidth,
- layoutParameters.interGlyphExtraAdvance,
- glyphPositionsBuffer + lineRun->glyphRun.glyphIndex - layoutParameters.startGlyphIndex );
+ const Vector<BidirectionalLineInfoRun>& bidirectionalLinesInfo = layoutParameters.textModel->mLogicalModel->mBidirectionalLineInfo;
+
+ if( layoutBidiParameters.isBidirectional )
+ {
+ layoutBidiParameters.bidiLineIndex = 0u;
+ for( Vector<BidirectionalLineInfoRun>::ConstIterator it = bidirectionalLinesInfo.Begin(),
+ endIt = bidirectionalLinesInfo.End();
+ it != endIt;
+ ++it, ++layoutBidiParameters.bidiLineIndex )
+ {
+ const BidirectionalLineInfoRun& run = *it;
+
+ if( ellipsisLayout.characterIndex == run.characterRun.characterIndex )
+ {
+ // Found where to insert the bidi line info.
+ break;
+ }
+ }
+ }
+
+ const BidirectionalLineInfoRun* const bidirectionalLineInfo = ( layoutBidiParameters.isBidirectional && !bidirectionalLinesInfo.Empty() ) ? &bidirectionalLinesInfo[layoutBidiParameters.bidiLineIndex] : nullptr;
+
+ if( ( nullptr != bidirectionalLineInfo ) &&
+ !bidirectionalLineInfo->isIdentity &&
+ ( ellipsisLayout.characterIndex == bidirectionalLineInfo->characterRun.characterIndex ) )
+ {
+ lineRun->direction = RTL;
+ SetGlyphPositions( layoutParameters,
+ glyphPositionsBuffer,
+ layoutBidiParameters,
+ ellipsisLayout );
+ }
+ else
+ {
+ lineRun->direction = LTR;
+ SetGlyphPositions( glyphsBuffer + lineRun->glyphRun.glyphIndex,
+ ellipsisLayout.numberOfGlyphs,
+ outlineWidth,
+ layoutParameters.interGlyphExtraAdvance,
+ glyphPositionsBuffer + lineRun->glyphRun.glyphIndex - layoutParameters.startGlyphIndex );
+ }
}
return ellipsis;
lineRun.glyphRun.numberOfGlyphs = layout.numberOfGlyphs;
lineRun.characterRun.characterIndex = layout.characterIndex;
lineRun.characterRun.numberOfCharacters = layout.numberOfCharacters;
- lineRun.lineSpacing = mDefaultLineSpacing;
+ lineRun.width = layout.length;
+ lineRun.extraLength = std::ceil( layout.whiteSpaceLengthEndOfLine );
- if( isLastLine && !layoutParameters.isLastNewParagraph )
- {
- const float width = layout.length + layout.wsLengthEndOfLine;
- if( MULTI_LINE_BOX == mLayout )
- {
- lineRun.width = ( width > layoutParameters.boundingBox.width ) ? layoutParameters.boundingBox.width : width;
- }
- else
- {
- lineRun.width = width;
- }
-
- lineRun.extraLength = 0.f;
- }
- else
- {
- lineRun.width = layout.length;
- lineRun.extraLength = std::ceil( layout.wsLengthEndOfLine );
- }
// Rounds upward to avoid a non integer size.
lineRun.width = std::ceil( lineRun.width );
lineRun.ascender = layout.ascender;
lineRun.descender = layout.descender;
- lineRun.direction = LTR;
+ lineRun.direction = layout.direction;
lineRun.ellipsis = false;
+ lineRun.lineSpacing = mDefaultLineSize - ( lineRun.ascender + -lineRun.descender );
+ lineRun.lineSpacing = lineRun.lineSpacing < 0.f ? 0.f : lineRun.lineSpacing;
+
+ lineRun.lineSpacing += mDefaultLineSpacing;
+
+
// Update the actual size.
if( lineRun.width > layoutSize.width )
{
lineRun.alignmentOffset = 0.f;
lineRun.direction = LTR;
lineRun.ellipsis = false;
- lineRun.lineSpacing = mDefaultLineSpacing;
+
+ lineRun.lineSpacing = mDefaultLineSize - ( lineRun.ascender + -lineRun.descender );
+ lineRun.lineSpacing = lineRun.lineSpacing < 0.f ? 0.f : lineRun.lineSpacing;
+
+ lineRun.lineSpacing += mDefaultLineSpacing;
layoutSize.height += ( lineRun.ascender + -lineRun.descender ) + lineRun.lineSpacing;
}
}
}
- bool LayoutText( const Parameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
+ bool LayoutText( Parameters& layoutParameters,
Size& layoutSize,
bool elideTextEnabled,
bool& isAutoScrollEnabled )
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->LayoutText\n" );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " box size %f, %f\n", layoutParameters.boundingBox.width, layoutParameters.boundingBox.height );
+ Vector<LineRun>& lines = layoutParameters.textModel->mVisualModel->mLines;
+
if( 0u == layoutParameters.numberOfGlyphs )
{
// Add an extra line if the last character is a new paragraph character and the last line doesn't have zero characters.
const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs;
const Length totalNumberOfGlyphs = layoutParameters.textModel->mVisualModel->mGlyphs.Count();
+ Vector<Vector2>& glyphPositions = layoutParameters.textModel->mVisualModel->mGlyphPositions;
// In a previous layout, an extra line with no characters may have been added if the text ended with a new paragraph character.
// This extra line needs to be removed.
// Retrieve BiDi info.
const bool hasBidiParagraphs = !layoutParameters.textModel->mLogicalModel->mBidirectionalParagraphInfo.Empty();
- const CharacterDirection* const characterDirectionBuffer = hasBidiParagraphs ? layoutParameters.textModel->mLogicalModel->mCharacterDirections.Begin() : nullptr;
+ const CharacterIndex* const glyphsToCharactersBuffer = hasBidiParagraphs ? layoutParameters.textModel->mVisualModel->mGlyphsToCharacters.Begin() : nullptr;
+ const Vector<BidirectionalParagraphInfoRun>& bidirectionalParagraphsInfo = layoutParameters.textModel->mLogicalModel->mBidirectionalParagraphInfo;
+ const Vector<BidirectionalLineInfoRun>& bidirectionalLinesInfo = layoutParameters.textModel->mLogicalModel->mBidirectionalLineInfo;
- // Set the first paragraph's direction.
- CharacterDirection paragraphDirection = ( nullptr != characterDirectionBuffer ) ? *characterDirectionBuffer : LTR;
+ // Set the layout bidirectional paramters.
+ LayoutBidiParameters layoutBidiParameters;
// Whether the layout is being updated or set from scratch.
const bool updateCurrentBuffer = layoutParameters.numberOfGlyphs < totalNumberOfGlyphs;
linesBuffer = lines.Begin();
}
-
- const GlyphInfo* const glyphsBuffer = layoutParameters.textModel->mVisualModel->mGlyphs.Begin();
- const float outlineWidth = static_cast<float>( layoutParameters.textModel->GetOutlineWidth() );
-
float penY = CalculateLineOffset( lines,
layoutParameters.startLineIndex );
-
-
for( GlyphIndex index = layoutParameters.startGlyphIndex; index < lastGlyphPlusOne; )
{
- CharacterDirection currentParagraphDirection = paragraphDirection;
+ layoutBidiParameters.Clear();
+
+ if( hasBidiParagraphs )
+ {
+ const CharacterIndex startCharacterIndex = *( glyphsToCharactersBuffer + index );
+
+ for( Vector<BidirectionalParagraphInfoRun>::ConstIterator it = bidirectionalParagraphsInfo.Begin(),
+ endIt = bidirectionalParagraphsInfo.End();
+ it != endIt;
+ ++it, ++layoutBidiParameters.bidiParagraphIndex )
+ {
+ const BidirectionalParagraphInfoRun& run = *it;
+
+ const CharacterIndex lastCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
+
+ if( lastCharacterIndex <= startCharacterIndex )
+ {
+ // Do not process, the paragraph has already been processed.
+ continue;
+ }
+
+ if( startCharacterIndex >= run.characterRun.characterIndex && startCharacterIndex < lastCharacterIndex )
+ {
+ layoutBidiParameters.paragraphDirection = run.direction;
+ layoutBidiParameters.isBidirectional = true;
+ }
+
+ // Has already been found.
+ break;
+ }
+
+ if( layoutBidiParameters.isBidirectional )
+ {
+ for( Vector<BidirectionalLineInfoRun>::ConstIterator it = bidirectionalLinesInfo.Begin(),
+ endIt = bidirectionalLinesInfo.End();
+ it != endIt;
+ ++it, ++layoutBidiParameters.bidiLineIndex )
+ {
+ const BidirectionalLineInfoRun& run = *it;
+
+ const CharacterIndex lastCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
+
+ if( lastCharacterIndex <= startCharacterIndex )
+ {
+ // skip
+ continue;
+ }
+
+ if( startCharacterIndex < lastCharacterIndex )
+ {
+ // Found where to insert the bidi line info.
+ break;
+ }
+ }
+ }
+ }
+
+ CharacterDirection currentParagraphDirection = layoutBidiParameters.paragraphDirection;
// Get the layout for the line.
LineLayout layout;
+ layout.direction = layoutBidiParameters.paragraphDirection;
layout.glyphIndex = index;
GetLineLayoutForBox( layoutParameters,
+ layoutBidiParameters,
layout,
- paragraphDirection,
false );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index %d\n", layout.glyphIndex );
bool ellipsis = false;
if( elideTextEnabled )
{
+ layoutBidiParameters.paragraphDirection = currentParagraphDirection;
+
// Does the ellipsis of the last line.
ellipsis = EllipsisLine( layoutParameters,
+ layoutBidiParameters,
layout,
layoutSize,
linesBuffer,
glyphPositionsBuffer,
numberOfLines,
penY,
- currentParagraphDirection,
isAutoScrollEnabled );
}
if( numberOfLines == linesCapacity )
{
+
// Reserve more space for the next lines.
linesBuffer = ResizeLinesBuffer( lines,
newLines,
numberOfLines );
} // whether to add a last line.
- // Sets the positions of the glyphs.
- SetGlyphPositions( glyphsBuffer + index,
- layout.numberOfGlyphs,
- outlineWidth,
- layoutParameters.interGlyphExtraAdvance,
- glyphPositionsBuffer + index - layoutParameters.startGlyphIndex );
+ const GlyphInfo* const glyphsBuffer = layoutParameters.textModel->mVisualModel->mGlyphs.Begin();
+ const float outlineWidth = static_cast<float>( layoutParameters.textModel->GetOutlineWidth() );
+
+ const BidirectionalLineInfoRun* const bidirectionalLineInfo = ( layoutBidiParameters.isBidirectional && !bidirectionalLinesInfo.Empty() ) ? &bidirectionalLinesInfo[layoutBidiParameters.bidiLineIndex] : nullptr;
+
+ if( ( nullptr != bidirectionalLineInfo ) &&
+ !bidirectionalLineInfo->isIdentity &&
+ ( layout.characterIndex == bidirectionalLineInfo->characterRun.characterIndex ) )
+ {
+ SetGlyphPositions( layoutParameters,
+ glyphPositionsBuffer,
+ layoutBidiParameters,
+ layout );
+ }
+ else
+ {
+
+ // Sets the positions of the glyphs.
+ SetGlyphPositions( glyphsBuffer + index,
+ layout.numberOfGlyphs,
+ outlineWidth,
+ layoutParameters.interGlyphExtraAdvance,
+ glyphPositionsBuffer + index - layoutParameters.startGlyphIndex );
+ }
// Updates the vertical pen's position.
penY += -layout.descender + layout.lineSpacing + mDefaultLineSpacing;
+ // If there is a defaultLineSize, updates the pen's position.
+ if( mDefaultLineSize > 0.f )
+ {
+ float lineSpacing = mDefaultLineSize - ( layout.ascender + -layout.descender );
+ lineSpacing = lineSpacing < 0.f ? 0.f : lineSpacing;
+ penY += lineSpacing;
+ }
// Increase the glyph index.
index = nextIndex;
return true;
}
- void ReLayoutRightToLeftLines( const Parameters& layoutParameters,
- CharacterIndex startIndex,
- Length numberOfCharacters,
- Vector<Vector2>& glyphPositions )
- {
- const GlyphInfo* const glyphsBuffer = layoutParameters.textModel->mVisualModel->mGlyphs.Begin();
- const GlyphIndex* const charactersToGlyphsBuffer = layoutParameters.textModel->mVisualModel->mCharactersToGlyph.Begin();
- const Length* const glyphsPerCharacterBuffer = layoutParameters.textModel->mVisualModel->mGlyphsPerCharacter.Begin();
- const float outlineWidth = static_cast<float>( layoutParameters.textModel->GetOutlineWidth() );
-
- const CharacterIndex lastCharacterIndex = startIndex + numberOfCharacters;
-
- // Traverses the paragraphs with right to left characters.
- for( LineIndex lineIndex = 0u; lineIndex < layoutParameters.numberOfBidirectionalInfoRuns; ++lineIndex )
- {
- const BidirectionalLineInfoRun& bidiLine = *( layoutParameters.lineBidirectionalInfoRunsBuffer + lineIndex );
-
- if( startIndex >= bidiLine.characterRun.characterIndex + bidiLine.characterRun.numberOfCharacters )
- {
- // Do not reorder the line if it has been already reordered.
- continue;
- }
-
- if( bidiLine.characterRun.characterIndex >= lastCharacterIndex )
- {
- // Do not reorder the lines after the last requested character.
- break;
- }
-
- const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *bidiLine.visualToLogicalMap;
- const GlyphInfo& glyph = *( glyphsBuffer + *( charactersToGlyphsBuffer + characterVisualIndex ) );
-
- float penX = -glyph.xBearing + outlineWidth + mCursorWidth;
-
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
-
- // Traverses the characters of the right to left paragraph.
- for( CharacterIndex characterLogicalIndex = 0u;
- characterLogicalIndex < bidiLine.characterRun.numberOfCharacters;
- ++characterLogicalIndex )
- {
- // Convert the character in the logical order into the character in the visual order.
- const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
-
- // Get the number of glyphs of the character.
- const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterVisualIndex );
-
- for( GlyphIndex index = 0u; index < numberOfGlyphs; ++index )
- {
- // Convert the character in the visual order into the glyph in the visual order.
- const GlyphIndex glyphIndex = *( charactersToGlyphsBuffer + characterVisualIndex ) + index;
-
- DALI_ASSERT_DEBUG( 0u <= glyphIndex && glyphIndex < layoutParameters.textModel->mVisualModel->mGlyphs.Count() );
-
- const GlyphInfo& glyph = *( glyphsBuffer + glyphIndex );
- Vector2& position = *( glyphPositionsBuffer + glyphIndex );
-
- position.x = std::round( penX + glyph.xBearing );
- penX += ( glyph.advance + layoutParameters.interGlyphExtraAdvance );
- }
- }
- }
- }
-
void Align( const Size& size,
CharacterIndex startIndex,
Length numberOfCharacters,
{
line.alignmentOffset = 0.f;
const bool isLineRTL = RTL == line.direction;
+
// Whether to swap the alignment.
// Swap if the line is RTL and is not required to match the direction of the system's language or if it's required to match the direction of the system's language and it's RTL.
bool isLayoutRTL = isLineRTL;
Type mLayout;
float mCursorWidth;
float mDefaultLineSpacing;
+ float mDefaultLineSize;
IntrusivePtr<Metrics> mMetrics;
};
Engine::Engine()
-: mImpl( nullptr )
+: mImpl{ nullptr }
{
mImpl = new Engine::Impl();
}
return static_cast<int>( mImpl->mCursorWidth );
}
-bool Engine::LayoutText( const Parameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
+bool Engine::LayoutText( Parameters& layoutParameters,
Size& layoutSize,
bool elideTextEnabled,
bool& isAutoScrollEnabled )
{
return mImpl->LayoutText( layoutParameters,
- glyphPositions,
- lines,
layoutSize,
elideTextEnabled,
isAutoScrollEnabled );
}
-void Engine::ReLayoutRightToLeftLines( const Parameters& layoutParameters,
- CharacterIndex startIndex,
- Length numberOfCharacters,
- Vector<Vector2>& glyphPositions )
-{
- mImpl->ReLayoutRightToLeftLines( layoutParameters,
- startIndex,
- numberOfCharacters,
- glyphPositions );
-}
-
void Engine::Align( const Size& size,
CharacterIndex startIndex,
Length numberOfCharacters,
return mImpl->mDefaultLineSpacing;
}
+void Engine::SetDefaultLineSize( float lineSize )
+{
+ mImpl->mDefaultLineSize = lineSize;
+}
+
+float Engine::GetDefaultLineSize() const
+{
+ return mImpl->mDefaultLineSize;
+}
+
} // namespace Layout
} // namespace Text
projects / platform / core / uifw / dali-toolkit.git / blobdiff