X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-controller-impl.cpp;h=7938931613878724ff42bd46e55a877ca80b2115;hp=c2c2fa86bd0bc52d763d74b9ed48e3f15118055f;hb=ded447ca28a294ce011a4c1f25f481b1cc04eefd;hpb=5b4982566aba41b5e21c3b8ce3e01a7e86db8f28 diff --git a/dali-toolkit/internal/text/text-controller-impl.cpp b/dali-toolkit/internal/text/text-controller-impl.cpp index c2c2fa8..7938931 100644 --- a/dali-toolkit/internal/text/text-controller-impl.cpp +++ b/dali-toolkit/internal/text/text-controller-impl.cpp @@ -26,9 +26,11 @@ #include #include #include +#include #include #include #include +#include namespace { @@ -37,28 +39,6 @@ namespace Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS"); #endif -/** - * @brief Some characters can be shaped in more than one glyph. - * This struct is used to retrieve metrics from these group of glyphs. - */ -struct GlyphMetrics -{ - GlyphMetrics() - : fontHeight( 0.f ), - advance( 0.f ), - ascender( 0.f ), - xBearing( 0.f ) - {} - - ~GlyphMetrics() - {} - - float fontHeight; ///< The font's height of that glyphs. - float advance; ///< The sum of all the advances of all the glyphs. - float ascender; ///< The font's ascender. - float xBearing; ///< The x bearing of the first glyph. -}; - } // namespace namespace Dali @@ -70,41 +50,6 @@ namespace Toolkit namespace Text { -/** - * @brief Get some glyph's metrics of a group of glyphs formed as a result of shaping one character. - * - * @param[in] glyphIndex The index to the first glyph. - * @param[in] numberOfGlyphs The number of glyphs. - * @param[out] glyphMetrics Some glyph metrics (font height, advance, ascender and x bearing). - * @param[in] visualModel The visual model. - * @param[in] metrics Used to access metrics from FontClient. - */ -void GetGlyphsMetrics( GlyphIndex glyphIndex, - Length numberOfGlyphs, - GlyphMetrics& glyphMetrics, - VisualModelPtr& visualModel, - MetricsPtr& metrics ) -{ - const GlyphInfo* glyphsBuffer = visualModel->mGlyphs.Begin(); - - const GlyphInfo& firstGlyph = *( glyphsBuffer + glyphIndex ); - - Text::FontMetrics fontMetrics; - metrics->GetFontMetrics( firstGlyph.fontId, fontMetrics ); - - glyphMetrics.fontHeight = fontMetrics.height; - glyphMetrics.advance = firstGlyph.advance; - glyphMetrics.ascender = fontMetrics.ascender; - glyphMetrics.xBearing = firstGlyph.xBearing; - - for( unsigned int i = 1u; i < numberOfGlyphs; ++i ) - { - const GlyphInfo& glyphInfo = *( glyphsBuffer + glyphIndex + i ); - - glyphMetrics.advance += glyphInfo.advance; - } -} - EventData::EventData( DecoratorPtr decorator ) : mDecorator( decorator ), mImfManager(), @@ -313,21 +258,415 @@ bool Controller::Impl::ProcessInputEvents() return decoratorUpdated; } -void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) +void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters ) +{ + mTextUpdateInfo.mParagraphCharacterIndex = 0u; + mTextUpdateInfo.mStartGlyphIndex = 0u; + mTextUpdateInfo.mStartLineIndex = 0u; + numberOfCharacters = 0u; + + const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count(); + if( 0u == numberOfParagraphs ) + { + mTextUpdateInfo.mParagraphCharacterIndex = 0u; + numberOfCharacters = 0u; + + mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove; + + // Nothing else to do if there are no paragraphs. + return; + } + + // Find the paragraphs to be updated. + Vector paragraphsToBeUpdated; + if( mTextUpdateInfo.mCharacterIndex >= mTextUpdateInfo.mPreviousNumberOfCharacters ) + { + // Text is being added at the end of the current text. + if( mTextUpdateInfo.mIsLastCharacterNewParagraph ) + { + // Text is being added in a new paragraph after the last character of the text. + mTextUpdateInfo.mParagraphCharacterIndex = mTextUpdateInfo.mPreviousNumberOfCharacters; + numberOfCharacters = 0u; + mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove; + + mTextUpdateInfo.mStartGlyphIndex = mVisualModel->mGlyphs.Count(); + mTextUpdateInfo.mStartLineIndex = mVisualModel->mLines.Count() - 1u; + + // Nothing else to do; + return; + } + + paragraphsToBeUpdated.PushBack( numberOfParagraphs - 1u ); + } + else + { + Length numberOfCharactersToUpdate = 0u; + if( mTextUpdateInfo.mFullRelayoutNeeded ) + { + numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters; + } + else + { + numberOfCharactersToUpdate = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u; + } + mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex, + numberOfCharactersToUpdate, + paragraphsToBeUpdated ); + } + + if( 0u != paragraphsToBeUpdated.Count() ) + { + const ParagraphRunIndex firstParagraphIndex = *( paragraphsToBeUpdated.Begin() ); + const ParagraphRun& firstParagraph = *( mLogicalModel->mParagraphInfo.Begin() + firstParagraphIndex ); + mTextUpdateInfo.mParagraphCharacterIndex = firstParagraph.characterRun.characterIndex; + + ParagraphRunIndex lastParagraphIndex = *( paragraphsToBeUpdated.End() - 1u ); + const ParagraphRun& lastParagraph = *( mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex ); + + if( ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) && // Some character are removed. + ( lastParagraphIndex < numberOfParagraphs - 1u ) && // There is a next paragraph. + ( ( lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters ) == // The last removed character is the new paragraph character. + ( mTextUpdateInfo.mCharacterIndex + mTextUpdateInfo.mNumberOfCharactersToRemove ) ) ) + { + // The new paragraph character of the last updated paragraph has been removed so is going to be merged with the next one. + const ParagraphRun& lastParagraph = *( mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex + 1u ); + + numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex; + } + else + { + numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex; + } + } + + mTextUpdateInfo.mRequestedNumberOfCharacters = numberOfCharacters + mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove; + mTextUpdateInfo.mStartGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex ); +} + +void Controller::Impl::ClearFullModelData( OperationsMask operations ) +{ + if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) ) + { + mLogicalModel->mLineBreakInfo.Clear(); + mLogicalModel->mParagraphInfo.Clear(); + } + + if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) ) + { + mLogicalModel->mLineBreakInfo.Clear(); + } + + if( NO_OPERATION != ( GET_SCRIPTS & operations ) ) + { + mLogicalModel->mScriptRuns.Clear(); + } + + if( NO_OPERATION != ( VALIDATE_FONTS & operations ) ) + { + mLogicalModel->mFontRuns.Clear(); + } + + if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() ) + { + if( NO_OPERATION != ( BIDI_INFO & operations ) ) + { + mLogicalModel->mBidirectionalParagraphInfo.Clear(); + mLogicalModel->mCharacterDirections.Clear(); + } + + if( NO_OPERATION != ( REORDER & operations ) ) + { + // Free the allocated memory used to store the conversion table in the bidirectional line info run. + for( Vector::Iterator it = mLogicalModel->mBidirectionalLineInfo.Begin(), + endIt = mLogicalModel->mBidirectionalLineInfo.End(); + it != endIt; + ++it ) + { + BidirectionalLineInfoRun& bidiLineInfo = *it; + + free( bidiLineInfo.visualToLogicalMap ); + bidiLineInfo.visualToLogicalMap = NULL; + } + mLogicalModel->mBidirectionalLineInfo.Clear(); + } + } + + if( NO_OPERATION != ( SHAPE_TEXT & operations ) ) + { + mVisualModel->mGlyphs.Clear(); + mVisualModel->mGlyphsToCharacters.Clear(); + mVisualModel->mCharactersToGlyph.Clear(); + mVisualModel->mCharactersPerGlyph.Clear(); + mVisualModel->mGlyphsPerCharacter.Clear(); + mVisualModel->mGlyphPositions.Clear(); + } + + if( NO_OPERATION != ( LAYOUT & operations ) ) + { + mVisualModel->mLines.Clear(); + } + + if( NO_OPERATION != ( COLOR & operations ) ) + { + mVisualModel->mColorIndices.Clear(); + } +} + +void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations ) +{ + const CharacterIndex endIndexPlusOne = endIndex + 1u; + + if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) ) + { + // Clear the line break info. + LineBreakInfo* lineBreakInfoBuffer = mLogicalModel->mLineBreakInfo.Begin(); + + mLogicalModel->mLineBreakInfo.Erase( lineBreakInfoBuffer + startIndex, + lineBreakInfoBuffer + endIndexPlusOne ); + + // Clear the paragraphs. + ClearCharacterRuns( startIndex, + endIndex, + mLogicalModel->mParagraphInfo ); + } + + if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) ) + { + // Clear the word break info. + WordBreakInfo* wordBreakInfoBuffer = mLogicalModel->mWordBreakInfo.Begin(); + + mLogicalModel->mWordBreakInfo.Erase( wordBreakInfoBuffer + startIndex, + wordBreakInfoBuffer + endIndexPlusOne ); + } + + if( NO_OPERATION != ( GET_SCRIPTS & operations ) ) + { + // Clear the scripts. + ClearCharacterRuns( startIndex, + endIndex, + mLogicalModel->mScriptRuns ); + } + + if( NO_OPERATION != ( VALIDATE_FONTS & operations ) ) + { + // Clear the fonts. + ClearCharacterRuns( startIndex, + endIndex, + mLogicalModel->mFontRuns ); + } + + if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() ) + { + if( NO_OPERATION != ( BIDI_INFO & operations ) ) + { + // Clear the bidirectional paragraph info. + ClearCharacterRuns( startIndex, + endIndex, + mLogicalModel->mBidirectionalParagraphInfo ); + + // Clear the character's directions. + CharacterDirection* characterDirectionsBuffer = mLogicalModel->mCharacterDirections.Begin(); + + mLogicalModel->mCharacterDirections.Erase( characterDirectionsBuffer + startIndex, + characterDirectionsBuffer + endIndexPlusOne ); + } + + if( NO_OPERATION != ( REORDER & operations ) ) + { + uint32_t startRemoveIndex = mLogicalModel->mBidirectionalLineInfo.Count(); + uint32_t endRemoveIndex = startRemoveIndex; + ClearCharacterRuns( startIndex, + endIndex, + mLogicalModel->mBidirectionalLineInfo, + startRemoveIndex, + endRemoveIndex ); + + BidirectionalLineInfoRun* bidirectionalLineInfoBuffer = mLogicalModel->mBidirectionalLineInfo.Begin(); + + // Free the allocated memory used to store the conversion table in the bidirectional line info run. + for( Vector::Iterator it = bidirectionalLineInfoBuffer + startRemoveIndex, + endIt = bidirectionalLineInfoBuffer + endRemoveIndex; + it != endIt; + ++it ) + { + BidirectionalLineInfoRun& bidiLineInfo = *it; + + free( bidiLineInfo.visualToLogicalMap ); + bidiLineInfo.visualToLogicalMap = NULL; + } + + mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex, + bidirectionalLineInfoBuffer + endRemoveIndex ); + } + } +} + +void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations ) +{ + const CharacterIndex endIndexPlusOne = endIndex + 1u; + const Length numberOfCharactersRemoved = endIndexPlusOne - startIndex; + + // Convert the character index to glyph index before deleting the character to glyph and the glyphs per character buffers. + GlyphIndex* charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); + Length* glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); + + const GlyphIndex endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex ); + const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex; + + if( NO_OPERATION != ( SHAPE_TEXT & operations ) ) + { + // Update the character to glyph indices. + for( Vector::Iterator it = charactersToGlyphBuffer + endIndexPlusOne, + endIt = charactersToGlyphBuffer + mVisualModel->mCharactersToGlyph.Count(); + it != endIt; + ++it ) + { + CharacterIndex& index = *it; + index -= numberOfGlyphsRemoved; + } + + // Clear the character to glyph conversion table. + mVisualModel->mCharactersToGlyph.Erase( charactersToGlyphBuffer + startIndex, + charactersToGlyphBuffer + endIndexPlusOne ); + + // Clear the glyphs per character table. + mVisualModel->mGlyphsPerCharacter.Erase( glyphsPerCharacterBuffer + startIndex, + glyphsPerCharacterBuffer + endIndexPlusOne ); + + // Clear the glyphs buffer. + GlyphInfo* glyphsBuffer = mVisualModel->mGlyphs.Begin(); + mVisualModel->mGlyphs.Erase( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, + glyphsBuffer + endGlyphIndexPlusOne ); + + CharacterIndex* glyphsToCharactersBuffer = mVisualModel->mGlyphsToCharacters.Begin(); + + // Update the glyph to character indices. + for( Vector::Iterator it = glyphsToCharactersBuffer + endGlyphIndexPlusOne, + endIt = glyphsToCharactersBuffer + mVisualModel->mGlyphsToCharacters.Count(); + it != endIt; + ++it ) + { + CharacterIndex& index = *it; + index -= numberOfCharactersRemoved; + } + + // Clear the glyphs to characters buffer. + mVisualModel->mGlyphsToCharacters.Erase( glyphsToCharactersBuffer + mTextUpdateInfo.mStartGlyphIndex, + glyphsToCharactersBuffer + endGlyphIndexPlusOne ); + + // Clear the characters per glyph buffer. + Length* charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); + mVisualModel->mCharactersPerGlyph.Erase( charactersPerGlyphBuffer + mTextUpdateInfo.mStartGlyphIndex, + charactersPerGlyphBuffer + endGlyphIndexPlusOne ); + + // Clear the positions buffer. + Vector2* positionsBuffer = mVisualModel->mGlyphPositions.Begin(); + mVisualModel->mGlyphPositions.Erase( positionsBuffer + mTextUpdateInfo.mStartGlyphIndex, + positionsBuffer + endGlyphIndexPlusOne ); + } + + if( NO_OPERATION != ( LAYOUT & operations ) ) + { + // Clear the lines. + uint32_t startRemoveIndex = mVisualModel->mLines.Count(); + uint32_t endRemoveIndex = startRemoveIndex; + ClearCharacterRuns( startIndex, + endIndex, + mVisualModel->mLines, + startRemoveIndex, + endRemoveIndex ); + + // Will update the glyph runs. + startRemoveIndex = mVisualModel->mLines.Count(); + endRemoveIndex = startRemoveIndex; + ClearGlyphRuns( mTextUpdateInfo.mStartGlyphIndex, + endGlyphIndexPlusOne - 1u, + mVisualModel->mLines, + startRemoveIndex, + endRemoveIndex ); + + // Set the line index from where to insert the new laid-out lines. + mTextUpdateInfo.mStartLineIndex = startRemoveIndex; + + LineRun* linesBuffer = mVisualModel->mLines.Begin(); + mVisualModel->mLines.Erase( linesBuffer + startRemoveIndex, + linesBuffer + endRemoveIndex ); + } + + if( NO_OPERATION != ( COLOR & operations ) ) + { + if( 0u != mVisualModel->mColorIndices.Count() ) + { + ColorIndex* colorIndexBuffer = mVisualModel->mColorIndices.Begin(); + mVisualModel->mColorIndices.Erase( colorIndexBuffer + mTextUpdateInfo.mStartGlyphIndex, + colorIndexBuffer + endGlyphIndexPlusOne ); + } + } +} + +void Controller::Impl::ClearModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations ) +{ + if( mTextUpdateInfo.mClearAll || + ( ( 0u == startIndex ) && + ( mTextUpdateInfo.mPreviousNumberOfCharacters == endIndex + 1u ) ) ) + { + ClearFullModelData( operations ); + } + else + { + // Clear the model data related with characters. + ClearCharacterModelData( startIndex, endIndex, operations ); + + // Clear the model data related with glyphs. + ClearGlyphModelData( startIndex, endIndex, operations ); + } + + // The estimated number of lines. Used to avoid reallocations when layouting. + mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mVisualModel->mLines.Count(), mLogicalModel->mParagraphInfo.Count() ); + + mVisualModel->ClearCaches(); +} + +bool Controller::Impl::UpdateModel( OperationsMask operationsRequired ) { DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel\n" ); // Calculate the operations to be done. const OperationsMask operations = static_cast( mOperationsPending & operationsRequired ); + if( NO_OPERATION == operations ) + { + // Nothing to do if no operations are pending and required. + return false; + } + Vector& utf32Characters = mLogicalModel->mText; const Length numberOfCharacters = utf32Characters.Count(); - Vector& lineBreakInfo = mLogicalModel->mLineBreakInfo; + // Index to the first character of the first paragraph to be updated. CharacterIndex startIndex = 0u; - Length requestedNumberOfCharacters = numberOfCharacters; - if( GET_LINE_BREAKS & operations ) + // Number of characters of the paragraphs to be removed. + Length paragraphCharacters = 0u; + + CalculateTextUpdateIndices( paragraphCharacters ); + startIndex = mTextUpdateInfo.mParagraphCharacterIndex; + + if( mTextUpdateInfo.mClearAll || + ( 0u != paragraphCharacters ) ) + { + ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operations ); + } + + mTextUpdateInfo.mClearAll = false; + + // Whether the model is updated. + bool updated = false; + + Vector& lineBreakInfo = mLogicalModel->mLineBreakInfo; + const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters; + + if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) ) { // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to // calculate the bidirectional info for each 'paragraph'. @@ -336,11 +675,18 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK ); SetLineBreakInfo( utf32Characters, + startIndex, + requestedNumberOfCharacters, lineBreakInfo ); + + // Create the paragraph info. + mLogicalModel->CreateParagraphInfo( startIndex, + requestedNumberOfCharacters ); + updated = true; } Vector& wordBreakInfo = mLogicalModel->mWordBreakInfo; - if( GET_WORD_BREAKS & operations ) + if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) ) { // Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines). wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK ); @@ -349,10 +695,11 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) startIndex, requestedNumberOfCharacters, wordBreakInfo ); + updated = true; } - const bool getScripts = GET_SCRIPTS & operations; - const bool validateFonts = VALIDATE_FONTS & operations; + const bool getScripts = NO_OPERATION != ( GET_SCRIPTS & operations ); + const bool validateFonts = NO_OPERATION != ( VALIDATE_FONTS & operations ); Vector& scripts = mLogicalModel->mScriptRuns; Vector& validFonts = mLogicalModel->mFontRuns; @@ -390,25 +737,14 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) requestedNumberOfCharacters, validFonts ); } + updated = true; } Vector mirroredUtf32Characters; bool textMirrored = false; - Length numberOfParagraphs = 0u; - if( BIDI_INFO & operations ) + const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count(); + if( NO_OPERATION != ( BIDI_INFO & operations ) ) { - // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's - // bidirectional info. - - const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin(); - for( Length index = 0u; index < numberOfCharacters; ++index ) - { - if( TextAbstraction::LINE_NO_BREAK == *( lineBreakInfoBuffer + index ) ) - { - ++numberOfParagraphs; - } - } - Vector& bidirectionalInfo = mLogicalModel->mBidirectionalParagraphInfo; bidirectionalInfo.Reserve( numberOfParagraphs ); @@ -445,6 +781,7 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) // There is no right to left characters. Clear the directions vector. mLogicalModel->mCharacterDirections.Clear(); } + updated = true; } Vector& glyphs = mVisualModel->mGlyphs; @@ -453,8 +790,8 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) Vector newParagraphGlyphs; newParagraphGlyphs.Reserve( numberOfParagraphs ); - GlyphIndex startGlyphIndex = 0u; - if( SHAPE_TEXT & operations ) + const Length currentNumberOfGlyphs = glyphs.Count(); + if( NO_OPERATION != ( SHAPE_TEXT & operations ) ) { const Vector& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters; // Shapes the text. @@ -463,7 +800,7 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) scripts, validFonts, startIndex, - startGlyphIndex, + mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters, glyphs, glyphsToCharactersMap, @@ -471,16 +808,17 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) newParagraphGlyphs ); // Create the 'number of glyphs' per character and the glyph to character conversion tables. - mVisualModel->CreateGlyphsPerCharacterTable( startIndex, numberOfCharacters ); - mVisualModel->CreateCharacterToGlyphTable( startIndex, numberOfCharacters ); + mVisualModel->CreateGlyphsPerCharacterTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters ); + mVisualModel->CreateCharacterToGlyphTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters ); + updated = true; } - const Length numberOfGlyphs = glyphs.Count(); + const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs; - if( GET_GLYPH_METRICS & operations ) + if( NO_OPERATION != ( GET_GLYPH_METRICS & operations ) ) { - GlyphInfo* glyphsBuffer = glyphs.Begin() + startGlyphIndex; - mMetrics->GetGlyphMetrics( glyphsBuffer, numberOfGlyphs ); + GlyphInfo* glyphsBuffer = glyphs.Begin(); + mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs ); // Update the width and advance of all new paragraph characters. for( Vector::ConstIterator it = newParagraphGlyphs.Begin(), endIt = newParagraphGlyphs.End(); it != endIt; ++it ) @@ -492,6 +830,22 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) glyph.width = 0.f; glyph.advance = 0.f; } + updated = true; + } + + if( NO_OPERATION != ( COLOR & operations ) ) + { + // Set the color runs in glyphs. + SetColorSegmentationInfo( mLogicalModel->mColorRuns, + mVisualModel->mCharactersToGlyph, + mVisualModel->mGlyphsPerCharacter, + startIndex, + mTextUpdateInfo.mStartGlyphIndex, + requestedNumberOfCharacters, + mVisualModel->mColors, + mVisualModel->mColorIndices ); + + updated = true; } if( ( NULL != mEventData ) && @@ -514,22 +868,12 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) // TODO: At the moment the underline runs are only for pre-edit. mVisualModel->mUnderlineRuns.PushBack( underlineRun ); } -} -bool Controller::Impl::UpdateModelStyle( OperationsMask operationsRequired ) -{ - bool updated = false; + // The estimated number of lines. Used to avoid reallocations when layouting. + mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mVisualModel->mLines.Count(), mLogicalModel->mParagraphInfo.Count() ); - if( COLOR & operationsRequired ) - { - // Set the color runs in glyphs. - SetColorSegmentationInfo( mLogicalModel->mColorRuns, - mVisualModel->mCharactersToGlyph, - mVisualModel->mGlyphsPerCharacter, - mVisualModel->mColorRuns ); - - updated = true; - } + // Set the previous number of characters for the next time the text is updated. + mTextUpdateInfo.mPreviousNumberOfCharacters = numberOfCharacters; return updated; } @@ -538,35 +882,52 @@ void Controller::Impl::RetrieveDefaultInputStyle( InputStyle& inputStyle ) { // Sets the default text's color. inputStyle.textColor = mTextColor; + inputStyle.isDefaultColor = true; + + inputStyle.familyName.clear(); + inputStyle.weight = TextAbstraction::FontWeight::NORMAL; + inputStyle.width = TextAbstraction::FontWidth::NORMAL; + inputStyle.slant = TextAbstraction::FontSlant::NORMAL; + inputStyle.size = 0.f; + + inputStyle.familyDefined = false; + inputStyle.weightDefined = false; + inputStyle.widthDefined = false; + inputStyle.slantDefined = false; + inputStyle.sizeDefined = false; // Sets the default font's family name, weight, width, slant and size. if( mFontDefaults ) { - inputStyle.familyName = mFontDefaults->mFontDescription.family; - inputStyle.weight = mFontDefaults->mFontDescription.weight; - inputStyle.width = mFontDefaults->mFontDescription.width; - inputStyle.slant = mFontDefaults->mFontDescription.slant; - inputStyle.size = mFontDefaults->mDefaultPointSize; + if( mFontDefaults->familyDefined ) + { + inputStyle.familyName = mFontDefaults->mFontDescription.family; + inputStyle.familyDefined = true; + } - inputStyle.familyDefined = mFontDefaults->familyDefined; - inputStyle.weightDefined = mFontDefaults->weightDefined; - inputStyle.widthDefined = mFontDefaults->widthDefined; - inputStyle.slantDefined = mFontDefaults->slantDefined; - inputStyle.sizeDefined = mFontDefaults->sizeDefined; - } - else - { - inputStyle.familyName.clear(); - inputStyle.weight = TextAbstraction::FontWeight::NORMAL; - inputStyle.width = TextAbstraction::FontWidth::NORMAL; - inputStyle.slant = TextAbstraction::FontSlant::NORMAL; - inputStyle.size = 0.f; + if( mFontDefaults->weightDefined ) + { + inputStyle.weight = mFontDefaults->mFontDescription.weight; + inputStyle.weightDefined = true; + } + + if( mFontDefaults->widthDefined ) + { + inputStyle.width = mFontDefaults->mFontDescription.width; + inputStyle.widthDefined = true; + } - inputStyle.familyDefined = false; - inputStyle.weightDefined = false; - inputStyle.widthDefined = false; - inputStyle.slantDefined = false; - inputStyle.sizeDefined = false; + if( mFontDefaults->slantDefined ) + { + inputStyle.slant = mFontDefaults->mFontDescription.slant; + inputStyle.slantDefined = true; + } + + if( mFontDefaults->sizeDefined ) + { + inputStyle.size = mFontDefaults->mDefaultPointSize; + inputStyle.sizeDefined = true; + } } } @@ -640,8 +1001,11 @@ void Controller::Impl::OnTapEvent( const Event& event ) const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x; const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y; - mEventData->mPrimaryCursorPosition = GetClosestCursorIndex( xPosition, - yPosition ); + mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel, + mLogicalModel, + mMetrics, + xPosition, + yPosition ); // When the cursor position is changing, delay cursor blinking mEventData->mDecorator->DelayCursorBlink(); @@ -678,7 +1042,7 @@ void Controller::Impl::OnPanEvent( const Event& event ) if( Gesture::Started == state || Gesture::Continuing == state ) { - const Vector2& actualSize = mVisualModel->GetActualSize(); + const Vector2& actualSize = mVisualModel->GetLayoutSize(); const Vector2 currentScroll = mEventData->mScrollPosition; if( mEventData->mHorizontalScrollingEnabled ) @@ -732,7 +1096,11 @@ void Controller::Impl::OnHandleEvent( const Event& event ) const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x; const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y; - const CharacterIndex handleNewPosition = GetClosestCursorIndex( xPosition, yPosition ); + const CharacterIndex handleNewPosition = Text::GetClosestCursorIndex( mVisualModel, + mLogicalModel, + mMetrics, + xPosition, + yPosition ); if( Event::GRAB_HANDLE_EVENT == event.type ) { @@ -779,7 +1147,11 @@ void Controller::Impl::OnHandleEvent( const Event& event ) const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x; const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y; - handlePosition = GetClosestCursorIndex( xPosition, yPosition ); + handlePosition = Text::GetClosestCursorIndex( mVisualModel, + mLogicalModel, + mMetrics, + xPosition, + yPosition ); } if( Event::GRAB_HANDLE_EVENT == event.type ) @@ -833,7 +1205,7 @@ void Controller::Impl::OnHandleEvent( const Event& event ) else if( HANDLE_SCROLLING == state ) { const float xSpeed = event.p2.mFloat; - const Vector2& actualSize = mVisualModel->GetActualSize(); + const Vector2& actualSize = mVisualModel->GetLayoutSize(); const Vector2 currentScrollPosition = mEventData->mScrollPosition; mEventData->mScrollPosition.x += xSpeed; @@ -866,8 +1238,11 @@ void Controller::Impl::OnHandleEvent( const Event& event ) // Get the new handle position. // The grab handle's position is in decorator coords. Need to transforms to text coords. - const CharacterIndex handlePosition = GetClosestCursorIndex( position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x, - position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y ); + const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel, + mLogicalModel, + mMetrics, + position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x, + position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y ); mEventData->mUpdateCursorPosition = mEventData->mPrimaryCursorPosition != handlePosition; mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateCursorPosition; @@ -888,8 +1263,11 @@ void Controller::Impl::OnHandleEvent( const Event& event ) // Get the new handle position. // The selection handle's position is in decorator coords. Need to transforms to text coords. - const CharacterIndex handlePosition = GetClosestCursorIndex( position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x, - position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y ); + const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel, + mLogicalModel, + mMetrics, + position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x, + position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y ); if( leftSelectionHandleEvent ) { @@ -982,12 +1360,13 @@ void Controller::Impl::RetrieveSelection( std::string& selectedText, bool delete const CharacterIndex startOfSelectedText = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition; const Length lengthOfSelectedText = ( handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition ) - startOfSelectedText; + Vector& utf32Characters = mLogicalModel->mText; + const Length numberOfCharacters = utf32Characters.Count(); + // Validate the start and end selection points - if( ( startOfSelectedText + lengthOfSelectedText ) <= mLogicalModel->mText.Count() ) + if( ( startOfSelectedText + lengthOfSelectedText ) <= numberOfCharacters ) { //Get text as a UTF8 string - Vector& utf32Characters = mLogicalModel->mText; - Utf32ToUtf8( &utf32Characters[startOfSelectedText], lengthOfSelectedText, selectedText ); if( deleteAfterRetrieval ) // Only delete text if copied successfully @@ -997,12 +1376,14 @@ void Controller::Impl::RetrieveSelection( std::string& selectedText, bool delete mLogicalModel->UpdateTextStyleRuns( startOfSelectedText, -static_cast( lengthOfSelectedText ) ); - // Delete text between handles - Vector& currentText = mLogicalModel->mText; + // Mark the paragraphs to be updated. + mTextUpdateInfo.mCharacterIndex = startOfSelectedText; + mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText; - Vector::Iterator first = currentText.Begin() + startOfSelectedText; + // Delete text between handles + Vector::Iterator first = utf32Characters.Begin() + startOfSelectedText; Vector::Iterator last = first + lengthOfSelectedText; - currentText.Erase( first, last ); + utf32Characters.Erase( first, last ); // Scroll after delete. mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition; @@ -1026,12 +1407,17 @@ void Controller::Impl::ShowClipboard() void Controller::Impl::HideClipboard() { - if( mClipboard ) + if( mClipboard && mClipboardHideEnabled ) { mClipboard.HideClipboard(); } } +void Controller::Impl::SetClipboardHideEnable(bool enable) +{ + mClipboardHideEnabled = enable; +} + bool Controller::Impl::CopyStringToClipboard( std::string& source ) { //Send string to clipboard @@ -1234,7 +1620,13 @@ void Controller::Impl::RepositionSelectionHandles( float visualX, float visualY // Find which word was selected CharacterIndex selectionStart( 0 ); CharacterIndex selectionEnd( 0 ); - FindSelectionIndices( visualX, visualY, selectionStart, selectionEnd ); + FindSelectionIndices( mVisualModel, + mLogicalModel, + mMetrics, + visualX, + visualY, + selectionStart, + selectionEnd ); DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p selectionStart %d selectionEnd %d\n", this, selectionStart, selectionEnd ); if( selectionStart == selectionEnd ) @@ -1468,212 +1860,9 @@ void Controller::Impl::ChangeState( EventData::State newState ) } } -LineIndex Controller::Impl::GetClosestLine( float y ) const -{ - float totalHeight = 0.f; - LineIndex lineIndex = 0u; - - const Vector& lines = mVisualModel->mLines; - for( LineIndex endLine = lines.Count(); - lineIndex < endLine; - ++lineIndex ) - { - const LineRun& lineRun = lines[lineIndex]; - totalHeight += lineRun.ascender + -lineRun.descender; - if( y < totalHeight ) - { - return lineIndex; - } - } - - if( lineIndex == 0 ) - { - return 0; - } - - return lineIndex-1; -} - -void Controller::Impl::FindSelectionIndices( float visualX, float visualY, CharacterIndex& startIndex, CharacterIndex& endIndex ) -{ - CharacterIndex hitCharacter = GetClosestCursorIndex( visualX, visualY ); - DALI_ASSERT_DEBUG( hitCharacter <= mLogicalModel->mText.Count() && "GetClosestCursorIndex returned out of bounds index" ); - - if( mLogicalModel->mText.Count() == 0 ) - { - return; // if model empty - } - - if( hitCharacter >= mLogicalModel->mText.Count() ) - { - // Closest hit character is the last character. - if( hitCharacter == mLogicalModel->mText.Count() ) - { - hitCharacter--; //Hit character index set to last character in logical model - } - else - { - // hitCharacter is out of bounds - return; - } - } - - startIndex = hitCharacter; - endIndex = hitCharacter; - bool isHitCharacterWhitespace = TextAbstraction::IsWhiteSpace( mLogicalModel->mText[hitCharacter] ); - - // Find the start and end of the text - for( startIndex = hitCharacter; startIndex > 0; --startIndex ) - { - if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ startIndex-1 ] ) ) - { - break; - } - } - const CharacterIndex pastTheEnd = mLogicalModel->mText.Count(); - for( endIndex = hitCharacter + 1u; endIndex < pastTheEnd; ++endIndex ) - { - if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ endIndex ] ) ) - { - break; - } - } -} - -CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX, - float visualY ) -{ - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetClosestCursorIndex %p closest visualX %f visualY %f\n", this, visualX, visualY ); - - if( NULL == mEventData ) - { - // Nothing to do if there is no text input. - return 0u; - } - - CharacterIndex logicalIndex = 0u; - - const Length numberOfGlyphs = mVisualModel->mGlyphs.Count(); - const Length numberOfLines = mVisualModel->mLines.Count(); - if( ( 0 == numberOfGlyphs ) || - ( 0 == numberOfLines ) ) - { - return logicalIndex; - } - - // Find which line is closest - const LineIndex lineIndex = GetClosestLine( visualY ); - const LineRun& line = mVisualModel->mLines[lineIndex]; - - // Get the positions of the glyphs. - const Vector& positions = mVisualModel->mGlyphPositions; - const Vector2* const positionsBuffer = positions.Begin(); - - // Get the visual to logical conversion tables. - const CharacterIndex* const visualToLogicalBuffer = ( 0u != mLogicalModel->mVisualToLogicalMap.Count() ) ? mLogicalModel->mVisualToLogicalMap.Begin() : NULL; - const CharacterIndex* const visualToLogicalCursorBuffer = mLogicalModel->mVisualToLogicalCursorMap.Begin(); - - // Get the character to glyph conversion table. - const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); - - // Get the glyphs per character table. - const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); - - // If the vector is void, there is no right to left characters. - const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer; - - const CharacterIndex startCharacter = line.characterRun.characterIndex; - const CharacterIndex endCharacter = line.characterRun.characterIndex + line.characterRun.numberOfCharacters; - DALI_ASSERT_DEBUG( endCharacter <= mLogicalModel->mText.Count() && "Invalid line info" ); - - // Whether there is a hit on a glyph. - bool matched = false; - - // Traverses glyphs in visual order. To do that use the visual to logical conversion table. - CharacterIndex visualIndex = startCharacter; - Length numberOfCharacters = 0u; - for( ; !matched && ( visualIndex < endCharacter ); ++visualIndex ) - { - // The character in logical order. - const CharacterIndex characterLogicalOrderIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + visualIndex ) : visualIndex; - - // Get the script of the character. - const Script script = mLogicalModel->GetScript( characterLogicalOrderIndex ); - - // The number of glyphs for that character - const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex ); - ++numberOfCharacters; - - - if( 0u != numberOfGlyphs ) - { - // Get the first character/glyph of the group of glyphs. - const CharacterIndex firstVisualCharacterIndex = 1u + visualIndex - numberOfCharacters; - const CharacterIndex firstLogicalCharacterIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + firstVisualCharacterIndex ) : firstVisualCharacterIndex; - const GlyphIndex firstLogicalGlyphIndex = *( charactersToGlyphBuffer + firstLogicalCharacterIndex ); - - // Get the metrics for the group of glyphs. - GlyphMetrics glyphMetrics; - GetGlyphsMetrics( firstLogicalGlyphIndex, - numberOfGlyphs, - glyphMetrics, - mVisualModel, - mMetrics ); - - // Get the position of the first glyph. - const Vector2& position = *( positionsBuffer + firstLogicalGlyphIndex ); - - // Whether the glyph can be split, like Latin ligatures fi, ff or Arabic ï»». - const bool isInterglyphIndex = ( numberOfCharacters > numberOfGlyphs ) && HasLigatureMustBreak( script ); - const Length numberOfBlocks = isInterglyphIndex ? numberOfCharacters : 1u; - const float glyphAdvance = glyphMetrics.advance / static_cast( numberOfBlocks ); - - GlyphIndex index = 0u; - for( ; !matched && ( index < numberOfBlocks ); ++index ) - { - // Find the mid-point of the area containing the glyph - const float glyphCenter = -glyphMetrics.xBearing + position.x + ( static_cast( index ) + 0.5f ) * glyphAdvance; - - if( visualX < glyphCenter ) - { - matched = true; - break; - } - } - - if( matched ) - { - visualIndex = firstVisualCharacterIndex + index; - break; - } - - numberOfCharacters = 0u; - } - - } - - - // Return the logical position of the cursor in characters. - - if( !matched ) - { - visualIndex = endCharacter; - } - - logicalIndex = hasRightToLeftCharacters ? *( visualToLogicalCursorBuffer + visualIndex ) : visualIndex; - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p closest visualIndex %d logicalIndex %d\n", this, visualIndex, logicalIndex ); - - DALI_ASSERT_DEBUG( ( logicalIndex <= mLogicalModel->mText.Count() && logicalIndex >= 0 ) && "GetClosestCursorIndex - Out of bounds index" ); - - return logicalIndex; -} - void Controller::Impl::GetCursorPosition( CharacterIndex logical, CursorInfo& cursorInfo ) { - // TODO: Check for multiline with \n, etc... - - const Length numberOfCharacters = mLogicalModel->mText.Count(); if( !IsShowingRealText() ) { // Do not want to use the place-holder text to set the cursor position. @@ -1728,181 +1917,29 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, return; } - // Check if the logical position is the first or the last one of the text. - const bool isFirstPosition = 0u == logical; - const bool isLastPosition = numberOfCharacters == logical; - - // 'logical' is the logical 'cursor' index. - // Get the next and current logical 'character' index. - const CharacterIndex nextCharacterIndex = logical; - const CharacterIndex characterIndex = isFirstPosition ? logical : logical - 1u; - - // Get the direction of the character and the next one. - const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL; - - CharacterDirection isCurrentRightToLeft = false; - CharacterDirection isNextRightToLeft = false; - if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right. - { - isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + characterIndex ); - isNextRightToLeft = *( modelCharacterDirectionsBuffer + nextCharacterIndex ); - } - - // Get the line where the character is laid-out. - const LineRun* const modelLines = mVisualModel->mLines.Begin(); + Text::GetCursorPosition( mVisualModel, + mLogicalModel, + mMetrics, + logical, + cursorInfo ); - const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( characterIndex ); - const LineRun& line = *( modelLines + lineIndex ); - - // Get the paragraph's direction. - const CharacterDirection isRightToLeftParagraph = line.direction; - - // Check whether there is an alternative position: - - cursorInfo.isSecondaryCursor = ( !isLastPosition && ( isCurrentRightToLeft != isNextRightToLeft ) ) || - ( isLastPosition && ( isRightToLeftParagraph != isCurrentRightToLeft ) ); - - // Set the line offset and height. - cursorInfo.lineOffset = 0.f; - cursorInfo.lineHeight = line.ascender + -line.descender; - - // Calculate the primary cursor. - - CharacterIndex index = characterIndex; - if( cursorInfo.isSecondaryCursor ) + if( LayoutEngine::MULTI_LINE_BOX == mLayoutEngine.GetLayout() ) { - // If there is a secondary position, the primary cursor may be in a different place than the logical index. - - if( isLastPosition ) - { - // The position of the cursor after the last character needs special - // care depending on its direction and the direction of the paragraph. + // If the text is editable and multi-line, the cursor position after a white space shouldn't exceed the boundaries of the text control. - // Need to find the first character after the last character with the paragraph's direction. - // i.e l0 l1 l2 r0 r1 should find r0. + // Note the white spaces laid-out at the end of the line might exceed the boundaries of the control. + // The reason is a wrapped line must not start with a white space so they are laid-out at the end of the line. - // TODO: check for more than one line! - index = isRightToLeftParagraph ? line.characterRun.characterIndex : line.characterRun.characterIndex + line.characterRun.numberOfCharacters - 1u; - index = mLogicalModel->GetLogicalCharacterIndex( index ); - } - else + if( 0.f > cursorInfo.primaryPosition.x ) { - index = ( isRightToLeftParagraph == isCurrentRightToLeft ) ? characterIndex : nextCharacterIndex; + cursorInfo.primaryPosition.x = 0.f; } - } - const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); - const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); - const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); - const CharacterIndex* const glyphsToCharactersBuffer = mVisualModel->mGlyphsToCharacters.Begin(); - const Vector2* const glyphPositionsBuffer = mVisualModel->mGlyphPositions.Begin(); - - // Convert the cursor position into the glyph position. - const GlyphIndex primaryGlyphIndex = *( charactersToGlyphBuffer + index ); - const Length primaryNumberOfGlyphs = *( glyphsPerCharacterBuffer + index ); - const Length primaryNumberOfCharacters = *( charactersPerGlyphBuffer + primaryGlyphIndex ); - - // Get the metrics for the group of glyphs. - GlyphMetrics glyphMetrics; - GetGlyphsMetrics( primaryGlyphIndex, - primaryNumberOfGlyphs, - glyphMetrics, - mVisualModel, - mMetrics ); - - // Whether to add the glyph's advance to the cursor position. - // i.e if the paragraph is left to right and the logical cursor is zero, the position is the position of the first glyph and the advance is not added, - // if the logical cursor is one, the position is the position of the first glyph and the advance is added. - // A 'truth table' was build and an online Karnaugh map tool was used to simplify the logic. - // - // FLCP A - // ------ - // 0000 1 - // 0001 1 - // 0010 0 - // 0011 0 - // 0100 1 - // 0101 0 - // 0110 1 - // 0111 0 - // 1000 0 - // 1001 x - // 1010 x - // 1011 1 - // 1100 x - // 1101 x - // 1110 x - // 1111 x - // - // Where F -> isFirstPosition - // L -> isLastPosition - // C -> isCurrentRightToLeft - // P -> isRightToLeftParagraph - // A -> Whether to add the glyph's advance. - - const bool addGlyphAdvance = ( ( isLastPosition && !isRightToLeftParagraph ) || - ( isFirstPosition && isRightToLeftParagraph ) || - ( !isFirstPosition && !isLastPosition && !isCurrentRightToLeft ) ); - - float glyphAdvance = addGlyphAdvance ? glyphMetrics.advance : 0.f; - - if( !isLastPosition && - ( primaryNumberOfCharacters > 1u ) ) - { - const CharacterIndex firstIndex = *( glyphsToCharactersBuffer + primaryGlyphIndex ); - - bool isCurrentRightToLeft = false; - if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right. - { - isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + index ); - } - - Length numberOfGlyphAdvance = ( isFirstPosition ? 0u : 1u ) + characterIndex - firstIndex; - if( isCurrentRightToLeft ) - { - numberOfGlyphAdvance = primaryNumberOfCharacters - numberOfGlyphAdvance; - } - - glyphAdvance = static_cast( numberOfGlyphAdvance ) * glyphMetrics.advance / static_cast( primaryNumberOfCharacters ); - } - - // Get the glyph position and x bearing. - const Vector2& primaryPosition = *( glyphPositionsBuffer + primaryGlyphIndex ); - - // Set the primary cursor's height. - cursorInfo.primaryCursorHeight = cursorInfo.isSecondaryCursor ? 0.5f * glyphMetrics.fontHeight : glyphMetrics.fontHeight; - - // Set the primary cursor's position. - cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + primaryPosition.x + glyphAdvance; - cursorInfo.primaryPosition.y = line.ascender - glyphMetrics.ascender; - - // Calculate the secondary cursor. - - if( cursorInfo.isSecondaryCursor ) - { - // Set the secondary cursor's height. - cursorInfo.secondaryCursorHeight = 0.5f * glyphMetrics.fontHeight; - - CharacterIndex index = characterIndex; - if( !isLastPosition ) + const float edgeWidth = mVisualModel->mControlSize.width - static_cast( mEventData->mDecorator->GetCursorWidth() ); + if( cursorInfo.primaryPosition.x > edgeWidth ) { - index = ( isRightToLeftParagraph == isCurrentRightToLeft ) ? nextCharacterIndex : characterIndex; + cursorInfo.primaryPosition.x = edgeWidth; } - - const GlyphIndex secondaryGlyphIndex = *( charactersToGlyphBuffer + index ); - const Length secondaryNumberOfGlyphs = *( glyphsPerCharacterBuffer + index ); - - const Vector2& secondaryPosition = *( glyphPositionsBuffer + secondaryGlyphIndex ); - - GetGlyphsMetrics( secondaryGlyphIndex, - secondaryNumberOfGlyphs, - glyphMetrics, - mVisualModel, - mMetrics ); - - // Set the secondary cursor's position. - cursorInfo.secondaryPosition.x = -glyphMetrics.xBearing + secondaryPosition.x + ( isCurrentRightToLeft ? 0.f : glyphMetrics.advance ); - cursorInfo.secondaryPosition.y = cursorInfo.lineHeight - cursorInfo.secondaryCursorHeight - line.descender - ( glyphMetrics.fontHeight - glyphMetrics.ascender ); } } @@ -2074,17 +2111,18 @@ void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position ) const float positionEnd = position.x + ( mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f ); // Transform the position to decorator coords. - const float offset = mEventData->mScrollPosition.x + mAlignmentOffset.x; + const float alignment = IsShowingRealText() ? mAlignmentOffset.x : 0.f; + const float offset = mEventData->mScrollPosition.x + alignment; const float decoratorPositionBegin = position.x + offset; const float decoratorPositionEnd = positionEnd + offset; if( decoratorPositionBegin < 0.f ) { - mEventData->mScrollPosition.x = -position.x - mAlignmentOffset.x; + mEventData->mScrollPosition.x = -position.x - alignment; } else if( decoratorPositionEnd > mVisualModel->mControlSize.width ) { - mEventData->mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd - mAlignmentOffset.x; + mEventData->mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd - alignment; } } @@ -2096,7 +2134,7 @@ void Controller::Impl::ScrollTextToMatchCursor( const CursorInfo& cursorInfo ) // Calculate the offset to match the cursor position before the character was deleted. mEventData->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x - mAlignmentOffset.x; - ClampHorizontalScroll( mVisualModel->GetActualSize() ); + ClampHorizontalScroll( mVisualModel->GetLayoutSize() ); } void Controller::Impl::RequestRelayout()