/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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/layouts/layout-parameters.h>
#include <dali-toolkit/internal/text/bidirectional-line-info-run.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>
namespace Dali
{
namespace Text
{
+namespace Layout
+{
+
namespace
{
const float MAX_FLOAT = std::numeric_limits<float>::max();
const bool RTL = true;
const float CURSOR_WIDTH = 1.f;
-
-Length CountParagraphs( const LayoutParameters& layoutParameters )
-{
- Length numberOfParagraphs = 0u;
-
- const CharacterIndex startCharacterIndex = *( layoutParameters.glyphsToCharactersBuffer + layoutParameters.startGlyphIndex );
-
- const GlyphIndex lastGlyphIndex = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs - 1u;
- const CharacterIndex lastCharacterIndexPlusOne = *( layoutParameters.glyphsToCharactersBuffer + lastGlyphIndex ) + *( layoutParameters.charactersPerGlyphBuffer + lastGlyphIndex );
-
- for( CharacterIndex index = startCharacterIndex; index < lastCharacterIndexPlusOne; ++index )
- {
- if( TextAbstraction::LINE_MUST_BREAK == *( layoutParameters.lineBreakInfoBuffer + index ) )
- {
- ++numberOfParagraphs;
- }
- }
-
- return numberOfParagraphs;
-}
+const float LINE_SPACING= 0.f;
} //namespace
float descender; ///< The minimum descender of all fonts in the line.
};
-struct LayoutEngine::Impl
+struct Engine::Impl
{
Impl()
- : mLayout( LayoutEngine::SINGLE_LINE_BOX ),
- mHorizontalAlignment( LayoutEngine::HORIZONTAL_ALIGN_BEGIN ),
- mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ),
+ : mLayout( Layout::Engine::SINGLE_LINE_BOX ),
mCursorWidth( CURSOR_WIDTH ),
- mEllipsisEnabled( false )
+ mDefaultLineSpacing( LINE_SPACING )
{
}
* @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 LayoutParameters& parameters,
+ void GetLineLayoutForBox( const Parameters& parameters,
LineLayout& lineLayout,
CharacterDirection& paragraphDirection,
bool completelyFill )
LineLayout tmpLineLayout;
const bool isMultiline = mLayout == MULTI_LINE_BOX;
- const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u;
+ const bool isWordLaidOut = parameters.lineWrapMode == Text::LineWrap::WORD;
+
+ // The last glyph to be laid-out.
+ const GlyphIndex lastGlyphOfParagraphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs;
// If the first glyph has a negative bearing its absolute value needs to be added to the line length.
// In the case the line starts with a right to left character, if the width is longer than the advance,
// the difference needs to be added to the line length.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + lineLayout.glyphIndex );
+
+ // Check whether the first glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( lineLayout.glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ parameters.charactersPerGlyphBuffer );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( lineLayout.glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ parameters.glyphsBuffer,
+ mMetrics );
// Set the direction of the first character of the line.
lineLayout.characterIndex = *( parameters.glyphsToCharactersBuffer + lineLayout.glyphIndex );
const CharacterDirection firstCharacterDirection = ( NULL == parameters.characterDirectionBuffer ) ? false : *( parameters.characterDirectionBuffer + lineLayout.characterIndex );
CharacterDirection previousCharacterDirection = firstCharacterDirection;
- const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance;
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
float tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
- float tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f;
+ float tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
tmpLineLayout.length += mCursorWidth; // Added to give some space to the cursor.
// Calculate the line height if there is no characters.
- FontId lastFontId = glyphInfo.fontId;
+ FontId lastFontId = glyphMetrics.fontId;
UpdateLineHeight( lastFontId, tmpLineLayout );
bool oneWordLaidOut = false;
- const GlyphIndex lastGlyphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs;
for( GlyphIndex glyphIndex = lineLayout.glyphIndex;
- glyphIndex < lastGlyphPlusOne;
- ++glyphIndex )
+ glyphIndex < lastGlyphOfParagraphPlusOne; )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index : %d\n", glyphIndex );
- const bool isLastGlyph = glyphIndex == lastGlyphIndex;
- // Get the glyph info.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + glyphIndex );
+ // Check whether this glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ parameters.charactersPerGlyphBuffer );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ parameters.glyphsBuffer,
+ mMetrics );
+
+ const bool isLastGlyph = glyphIndex + numberOfGLyphsInGroup == parameters.totalNumberOfGlyphs;
// Check if the font of the current glyph is the same of the previous one.
// If it's different the ascender and descender need to be updated.
- if( lastFontId != glyphInfo.fontId )
+ if( lastFontId != glyphMetrics.fontId )
{
- UpdateLineHeight( glyphInfo.fontId, tmpLineLayout );
- lastFontId = glyphInfo.fontId;
+ UpdateLineHeight( glyphMetrics.fontId, tmpLineLayout );
+ lastFontId = glyphMetrics.fontId;
}
// Get the character indices for the current glyph. The last character index is needed
// because there are glyphs formed by more than one character but their break info is
// given only for the last character.
- const Length charactersPerGlyph = *( parameters.charactersPerGlyphBuffer + glyphIndex );
+ const Length charactersPerGlyph = *( parameters.charactersPerGlyphBuffer + glyphIndex + numberOfGLyphsInGroup - 1u );
+ const bool hasCharacters = charactersPerGlyph > 0u;
const CharacterIndex characterFirstIndex = *( parameters.glyphsToCharactersBuffer + glyphIndex );
- const CharacterIndex characterLastIndex = characterFirstIndex + ( ( 1u > charactersPerGlyph ) ? 0u : charactersPerGlyph - 1u );
+ const CharacterIndex characterLastIndex = characterFirstIndex + ( hasCharacters ? charactersPerGlyph - 1u : 0u );
// Get the line break info for the current character.
- const LineBreakInfo lineBreakInfo = *( parameters.lineBreakInfoBuffer + characterLastIndex );
+ const LineBreakInfo lineBreakInfo = hasCharacters ? *( parameters.lineBreakInfoBuffer + characterLastIndex ) : TextAbstraction::LINE_NO_BREAK;
// Get the word break info for the current character.
const WordBreakInfo wordBreakInfo = *( parameters.wordBreakInfoBuffer + characterLastIndex );
tmpLineLayout.numberOfCharacters += charactersPerGlyph;
// Increase the number of glyphs.
- tmpLineLayout.numberOfGlyphs++;
+ tmpLineLayout.numberOfGlyphs += numberOfGLyphsInGroup;
// Check whether is a white space.
const Character character = *( parameters.textBuffer + characterFirstIndex );
if( isWhiteSpace )
{
// Add the length to the length of white spaces at the end of the line.
- tmpLineLayout.wsLengthEndOfLine += glyphInfo.advance; // The advance is used as the width is always zero for the white spaces.
+ tmpLineLayout.wsLengthEndOfLine += glyphMetrics.advance; // The advance is used as the width is always zero for the white spaces.
}
else
{
// Add as well any previous white space length.
- tmpLineLayout.length += tmpLineLayout.wsLengthEndOfLine + glyphInfo.advance;
+ tmpLineLayout.length += tmpLineLayout.wsLengthEndOfLine + glyphMetrics.advance;
// An extra space may be added to the line for the first and last glyph of the line.
// If the bearing of the first glyph is negative, its positive value needs to be added.
// | Rll|
//
- tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f;
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
}
else // LTR
{
// |rrL |
//
- const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance;
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
}
}
// -->
// |lllR |
- const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance;
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
}
else // LTR
// <--
// | Lrrrr|
- tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f;
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
}
}
else if( characterDirection == firstCharacterDirection )
// |llllllrr|
// |Rr |
- tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f;
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
}
else // LTR
{
// |llllrrrr|
// | llL|
- const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance;
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
}
}
if( tmpLineLayout.numberOfGlyphs > 0u )
{
tmpLineLayout.numberOfCharacters -= charactersPerGlyph;
- --tmpLineLayout.numberOfGlyphs;
+ tmpLineLayout.numberOfGlyphs -= numberOfGLyphsInGroup;
tmpLineLayout.length = previousTmpLineLength;
tmpExtraBearing = previousTmpExtraBearing;
tmpExtraWidth = previousTmpExtraWidth;
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
+
return;
}
if( isMultiline &&
( TextAbstraction::WORD_BREAK == wordBreakInfo ) )
{
- oneWordLaidOut = true;
+ oneWordLaidOut = isWordLaidOut;
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " One word laid-out\n" );
// Current glyph is the last one of the current word.
}
previousCharacterDirection = characterDirection;
+ glyphIndex += numberOfGLyphsInGroup;
}
lineLayout.extraBearing = tmpExtraBearing;
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
}
- /**
- * @brief Calculates the vertical offset to add to the new laid-out glyphs.
- *
- * @pre @p lineIndex must be between 0 and the number of lines (both inclusive).
- *
- * @param[in] lines The previously laid-out lines.
- * @param[in] lineIndex Index to the line where the new laid-out lines are inserted.
- *
- * @return The vertical offset of the lines starting from the beginning to the line @p lineIndex.
- */
- float SetParagraphOffset( const Vector<LineRun>& lines,
- LineIndex lineIndex )
- {
- float offset = 0.f;
-
- for( Vector<LineRun>::ConstIterator it = lines.Begin(),
- endIt = lines.Begin() + lineIndex;
- it != endIt;
- ++it )
- {
- const LineRun& line = *it;
-
- offset += line.ascender + -line.descender;
- }
-
- return offset;
- }
-
void SetGlyphPositions( const GlyphInfo* const glyphsBuffer,
Length numberOfGlyphs,
- float penY,
+ float outlineWidth,
Vector2* glyphPositionsBuffer )
{
// Traverse the glyphs and set the positions.
// so the penX position needs to be moved to the right.
const GlyphInfo& glyph = *glyphsBuffer;
- float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing : 0.f;
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing + outlineWidth : outlineWidth;
+
for( GlyphIndex i = 0u; i < numberOfGlyphs; ++i )
{
Vector2& position = *( glyphPositionsBuffer + i );
position.x = penX + glyph.xBearing;
- position.y = penY - glyph.yBearing;
+ position.y = -glyph.yBearing;
penX += glyph.advance;
}
*
* return Whether the line is ellipsized.
*/
- bool EllipsisLine( const LayoutParameters& layoutParameters,
+ bool EllipsisLine( const Parameters& layoutParameters,
const LineLayout& layout,
Size& layoutSize,
LineRun* linesBuffer,
lineRun->ellipsis = true;
layoutSize.width = layoutParameters.boundingBox.width;
- layoutSize.height += ( lineRun->ascender + -lineRun->descender );
+ if( layoutSize.height < Math::MACHINE_EPSILON_1000 )
+ {
+ layoutSize.height += ( lineRun->ascender + -lineRun->descender );
+ }
SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun->glyphRun.glyphIndex,
ellipsisLayout.numberOfGlyphs,
- penY,
+ layoutParameters.outlineWidth,
glyphPositionsBuffer + lineRun->glyphRun.glyphIndex - layoutParameters.startGlyphIndex );
}
* @param[in,out] numberOfLines The number of laid-out lines.
* @param[in] isLastLine Whether the laid-out line is the last one.
*/
- void UpdateTextLayout( const LayoutParameters& layoutParameters,
+ void UpdateTextLayout( const Parameters& layoutParameters,
const LineLayout& layout,
Size& layoutSize,
LineRun* linesBuffer,
* @brief Updates the text layout with the last laid-out line.
*
* @param[in] layoutParameters The parameters needed to layout the text.
- * @param[in] layout The line layout.
+ * @param[in] characterIndex The character index of the line.
+ * @param[in] glyphIndex The glyph index of the line.
* @param[in,out] layoutSize The text's layout size.
* @param[in,out] linesBuffer Pointer to the line's buffer.
- * @param[in] index Index to the vector of glyphs.
* @param[in,out] numberOfLines The number of laid-out lines.
*/
- void UpdateTextLayout( const LayoutParameters& layoutParameters,
- const LineLayout& layout,
+ void UpdateTextLayout( const Parameters& layoutParameters,
+ CharacterIndex characterIndex,
+ GlyphIndex glyphIndex,
Size& layoutSize,
LineRun* linesBuffer,
- GlyphIndex index,
Length& numberOfLines )
{
// Need to add a new line with no characters but with height to increase the layoutSize.height
LineRun& lineRun = *( linesBuffer + numberOfLines );
++numberOfLines;
- lineRun.glyphRun.glyphIndex = index + layout.numberOfGlyphs;
+ lineRun.glyphRun.glyphIndex = glyphIndex;
lineRun.glyphRun.numberOfGlyphs = 0u;
- lineRun.characterRun.characterIndex = layout.characterIndex + layout.numberOfCharacters;
+ lineRun.characterRun.characterIndex = characterIndex;
lineRun.characterRun.numberOfCharacters = 0u;
lineRun.width = 0.f;
lineRun.ascender = fontMetrics.ascender;
* @param[in] characterOffset The offset to be added to the runs of characters.
* @param[in] glyphOffset The offset to be added to the runs of glyphs.
*/
- void UpdateLineIndexOffsets( const LayoutParameters& layoutParameters,
+ void UpdateLineIndexOffsets( const Parameters& layoutParameters,
Vector<LineRun>& lines,
Length characterOffset,
Length glyphOffset )
}
}
- bool LayoutText( const LayoutParameters& layoutParameters,
+ bool LayoutText( const Parameters& layoutParameters,
Vector<Vector2>& glyphPositions,
Vector<LineRun>& lines,
- Size& layoutSize )
+ Size& layoutSize,
+ bool elideTextEnabled )
{
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 );
if( 0u == layoutParameters.numberOfGlyphs )
{
- // Nothing to do if there are no glyphs to layout.
+ // Add an extra line if the last character is a new paragraph character and the last line doesn't have zero characters.
+ if( layoutParameters.isLastNewParagraph )
+ {
+ Length numberOfLines = lines.Count();
+ if( 0u != numberOfLines )
+ {
+ const LineRun& lastLine = *( lines.End() - 1u );
+
+ if( 0u != lastLine.characterRun.numberOfCharacters )
+ {
+ // Need to add a new line with no characters but with height to increase the layoutSize.height
+ LineRun newLine;
+ Initialize( newLine );
+ lines.PushBack( newLine );
+
+ UpdateTextLayout( layoutParameters,
+ lastLine.characterRun.characterIndex + lastLine.characterRun.numberOfCharacters,
+ lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs,
+ layoutSize,
+ lines.Begin(),
+ numberOfLines );
+ }
+ }
+ }
+
+ // Calculates the layout size.
+ UpdateLayoutSize( lines,
+ layoutSize );
+
+ // Nothing else do if there are no glyphs to layout.
return false;
}
+ const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs;
+
+ // 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.
+ if( 0u != lines.Count() )
+ {
+ Vector<LineRun>::Iterator lastLine = lines.End() - 1u;
+
+ if( ( 0u == lastLine->characterRun.numberOfCharacters ) &&
+ ( lastGlyphPlusOne == layoutParameters.totalNumberOfGlyphs ) )
+ {
+ lines.Remove( lastLine );
+ }
+ }
+
// Set the first paragraph's direction.
CharacterDirection paragraphDirection = ( NULL != layoutParameters.characterDirectionBuffer ) ? *layoutParameters.characterDirectionBuffer : !RTL;
Vector<LineRun> newLines;
// Estimate the number of lines.
- // TODO: In a next patch the paragraphs are properly managed and this can be removed.
- Length linesCapacity = CountParagraphs( layoutParameters );
+ Length linesCapacity = std::max( 1u, layoutParameters.estimatedNumberOfLines );
Length numberOfLines = 0u;
if( updateCurrentBuffer )
linesBuffer = lines.Begin();
}
- float penY = SetParagraphOffset( lines,
- layoutParameters.startLineIndex );
+ float penY = CalculateLineOffset( lines,
+ layoutParameters.startLineIndex );
- const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs;
for( GlyphIndex index = layoutParameters.startGlyphIndex; index < lastGlyphPlusOne; )
{
CharacterDirection currentParagraphDirection = paragraphDirection;
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " pen y %f\n", penY );
bool ellipsis = false;
- if( mEllipsisEnabled )
+ if( elideTextEnabled )
{
// Does the ellipsis of the last line.
ellipsis = EllipsisLine( layoutParameters,
numberOfLines,
isLastLine );
- if( isLastLine &&
+ const GlyphIndex nextIndex = index + layout.numberOfGlyphs;
+
+ if( ( nextIndex == layoutParameters.totalNumberOfGlyphs ) &&
layoutParameters.isLastNewParagraph &&
( mLayout == MULTI_LINE_BOX ) )
{
}
UpdateTextLayout( layoutParameters,
- layout,
+ layout.characterIndex + layout.numberOfCharacters,
+ index + layout.numberOfGlyphs,
layoutSize,
linesBuffer,
- index,
numberOfLines );
} // whether to add a last line.
// Sets the positions of the glyphs.
SetGlyphPositions( layoutParameters.glyphsBuffer + index,
layout.numberOfGlyphs,
- penY,
+ layoutParameters.outlineWidth,
glyphPositionsBuffer + index - layoutParameters.startGlyphIndex );
// Updates the vertical pen's position.
penY += -layout.descender;
// Increase the glyph index.
- index += layout.numberOfGlyphs;
-
+ index = nextIndex;
} // no ellipsis
} // end for() traversing glyphs.
glyphPositions.Insert( glyphPositions.Begin() + layoutParameters.startGlyphIndex,
newGlyphPositions.Begin(),
newGlyphPositions.End() );
+ glyphPositions.Resize( layoutParameters.totalNumberOfGlyphs );
newLines.Resize( numberOfLines );
return true;
}
- void ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
+ void ReLayoutRightToLeftLines( const Parameters& layoutParameters,
CharacterIndex startIndex,
Length numberOfCharacters,
Vector<Vector2>& glyphPositions )
const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *bidiLine.visualToLogicalMap;
const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + *( layoutParameters.charactersToGlyphsBuffer + characterVisualIndex ) );
- float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing : 0.f;
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing - layoutParameters.outlineWidth : -layoutParameters.outlineWidth;
Vector2* glyphPositionsBuffer = glyphPositions.Begin();
void Align( const Size& size,
CharacterIndex startIndex,
Length numberOfCharacters,
- Vector<LineRun>& lines )
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset )
{
const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters;
+ alignmentOffset = MAX_FLOAT;
// Traverse all lines and align the glyphs.
for( Vector<LineRun>::Iterator it = lines.Begin(), endIt = lines.End();
it != endIt;
// Calculate the line's alignment offset accordingly with the align option,
// the box width, line length, and the paragraph's direction.
CalculateHorizontalAlignment( size.width,
+ horizontalAlignment,
line );
+
+ // Updates the alignment offset.
+ alignmentOffset = std::min( alignmentOffset, line.alignmentOffset );
}
}
void CalculateHorizontalAlignment( float boxWidth,
+ HorizontalAlignment::Type horizontalAlignment,
LineRun& line )
{
line.alignmentOffset = 0.f;
const bool isRTL = RTL == line.direction;
float lineLength = line.width;
- HorizontalAlignment alignment = mHorizontalAlignment;
+ HorizontalAlignment::Type alignment = horizontalAlignment;
if( isRTL )
{
// Swap the alignment type if the line is right to left.
switch( alignment )
{
- case HORIZONTAL_ALIGN_BEGIN:
+ case HorizontalAlignment::BEGIN:
{
- alignment = HORIZONTAL_ALIGN_END;
+ alignment = HorizontalAlignment::END;
break;
}
- case HORIZONTAL_ALIGN_CENTER:
+ case HorizontalAlignment::CENTER:
{
// Nothing to do.
break;
}
- case HORIZONTAL_ALIGN_END:
+ case HorizontalAlignment::END:
{
- alignment = HORIZONTAL_ALIGN_BEGIN;
+ alignment = HorizontalAlignment::BEGIN;
break;
}
}
// Calculate the horizontal line offset.
switch( alignment )
{
- case HORIZONTAL_ALIGN_BEGIN:
+ case HorizontalAlignment::BEGIN:
{
line.alignmentOffset = 0.f;
}
break;
}
- case HORIZONTAL_ALIGN_CENTER:
+ case HorizontalAlignment::CENTER:
{
line.alignmentOffset = 0.5f * ( boxWidth - lineLength );
line.alignmentOffset = floorf( line.alignmentOffset ); // try to avoid pixel alignment.
break;
}
- case HORIZONTAL_ALIGN_END:
+ case HorizontalAlignment::END:
{
if( isRTL )
{
}
}
- LayoutEngine::Layout mLayout;
- LayoutEngine::HorizontalAlignment mHorizontalAlignment;
- LayoutEngine::VerticalAlignment mVerticalAlignment;
+ void Initialize( LineRun& line )
+ {
+ line.glyphRun.glyphIndex = 0u;
+ line.glyphRun.numberOfGlyphs = 0u;
+ line.characterRun.characterIndex = 0u;
+ line.characterRun.numberOfCharacters = 0u;
+ line.width = 0.f;
+ line.ascender = 0.f;
+ line.descender = 0.f;
+ line.extraLength = 0.f;
+ line.alignmentOffset = 0.f;
+ line.direction = !RTL;
+ line.ellipsis = false;
+ }
+
+ Type mLayout;
float mCursorWidth;
+ float mDefaultLineSpacing;
IntrusivePtr<Metrics> mMetrics;
-
- bool mEllipsisEnabled:1;
};
-LayoutEngine::LayoutEngine()
+Engine::Engine()
: mImpl( NULL )
{
- mImpl = new LayoutEngine::Impl();
+ mImpl = new Engine::Impl();
}
-LayoutEngine::~LayoutEngine()
+Engine::~Engine()
{
delete mImpl;
}
-void LayoutEngine::SetMetrics( MetricsPtr& metrics )
+void Engine::SetMetrics( MetricsPtr& metrics )
{
mImpl->mMetrics = metrics;
}
-void LayoutEngine::SetLayout( Layout layout )
+void Engine::SetLayout( Type layout )
{
mImpl->mLayout = layout;
}
-LayoutEngine::Layout LayoutEngine::GetLayout() const
+Engine::Type Engine::GetLayout() const
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetLayout[%d]\n", mImpl->mLayout);
return mImpl->mLayout;
}
-void LayoutEngine::SetTextEllipsisEnabled( bool enabled )
-{
- mImpl->mEllipsisEnabled = enabled;
-}
-
-bool LayoutEngine::GetTextEllipsisEnabled() const
-{
- return mImpl->mEllipsisEnabled;
-}
-
-void LayoutEngine::SetHorizontalAlignment( HorizontalAlignment alignment )
-{
- mImpl->mHorizontalAlignment = alignment;
-}
-
-LayoutEngine::HorizontalAlignment LayoutEngine::GetHorizontalAlignment() const
-{
- return mImpl->mHorizontalAlignment;
-}
-
-void LayoutEngine::SetVerticalAlignment( VerticalAlignment alignment )
-{
- mImpl->mVerticalAlignment = alignment;
-}
-
-LayoutEngine::VerticalAlignment LayoutEngine::GetVerticalAlignment() const
-{
- return mImpl->mVerticalAlignment;
-}
-
-void LayoutEngine::SetCursorWidth( int width )
+void Engine::SetCursorWidth( int width )
{
mImpl->mCursorWidth = static_cast<float>( width );
}
-int LayoutEngine::GetCursorWidth() const
+int Engine::GetCursorWidth() const
{
return static_cast<int>( mImpl->mCursorWidth );
}
-bool LayoutEngine::LayoutText( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& layoutSize )
+bool Engine::LayoutText( const Parameters& layoutParameters,
+ Vector<Vector2>& glyphPositions,
+ Vector<LineRun>& lines,
+ Size& layoutSize,
+ bool elideTextEnabled )
{
return mImpl->LayoutText( layoutParameters,
glyphPositions,
lines,
- layoutSize );
+ layoutSize,
+ elideTextEnabled );
}
-void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
- CharacterIndex startIndex,
- Length numberOfCharacters,
- Vector<Vector2>& glyphPositions )
+void Engine::ReLayoutRightToLeftLines( const Parameters& layoutParameters,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Vector<Vector2>& glyphPositions )
{
mImpl->ReLayoutRightToLeftLines( layoutParameters,
startIndex,
glyphPositions );
}
-void LayoutEngine::Align( const Size& size,
- CharacterIndex startIndex,
- Length numberOfCharacters,
- Vector<LineRun>& lines )
+void Engine::Align( const Size& size,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset )
{
mImpl->Align( size,
startIndex,
numberOfCharacters,
- lines );
+ horizontalAlignment,
+ lines,
+ alignmentOffset );
+}
+
+void Engine::SetDefaultLineSpacing( float lineSpacing )
+{
+ mImpl->mDefaultLineSpacing = lineSpacing;
+}
+
+float Engine::GetDefaultLineSpacing() const
+{
+ return mImpl->mDefaultLineSpacing;
}
+} // namespace Layout
+
} // namespace Text
} // namespace Toolkit