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=b1c0b14c63abfda5d824fac9e7926fe762d1d037;hp=12fbb2fc0272584198c68a166c7fde77eb237744;hb=91b718d20fa4a1f9e2f13ae25a730cc0e464da12;hpb=9f3a3fb55f6649f558e72e4b3a3ffdbe3525f617 diff --git a/dali-toolkit/internal/text/text-controller-impl.cpp b/dali-toolkit/internal/text/text-controller-impl.cpp index 12fbb2f..b1c0b14 100644 --- a/dali-toolkit/internal/text/text-controller-impl.cpp +++ b/dali-toolkit/internal/text/text-controller-impl.cpp @@ -25,19 +25,15 @@ // INTERNAL INCLUDES #include #include -#include #include -#include #include #include -#include -#include namespace { #if defined(DEBUG_ENABLED) - Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS"); + Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS"); #endif /** @@ -62,8 +58,6 @@ struct GlyphMetrics float xBearing; ///< The x bearing of the first glyph. }; -const std::string EMPTY_STRING(""); - } // namespace namespace Dali @@ -82,20 +76,20 @@ namespace Text * @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] fontClient The font client. + * @param[in] metrics Used to access metrics from FontClient. */ void GetGlyphsMetrics( GlyphIndex glyphIndex, Length numberOfGlyphs, GlyphMetrics& glyphMetrics, - VisualModelPtr visualModel, - TextAbstraction::FontClient& fontClient ) + VisualModelPtr& visualModel, + MetricsPtr& metrics ) { const GlyphInfo* glyphsBuffer = visualModel->mGlyphs.Begin(); const GlyphInfo& firstGlyph = *( glyphsBuffer + glyphIndex ); Text::FontMetrics fontMetrics; - fontClient.GetFontMetrics( firstGlyph.fontId, fontMetrics ); + metrics->GetFontMetrics( firstGlyph.fontId, fontMetrics ); glyphMetrics.fontHeight = fontMetrics.height; glyphMetrics.advance = firstGlyph.advance; @@ -206,62 +200,81 @@ bool Controller::Impl::ProcessInputEvents() if( mEventData->mUpdateCursorPosition ) { // Updates the cursor position and scrolls the text to make it visible. - - UpdateCursorPosition(); + CursorInfo cursorInfo; + GetCursorPosition( mEventData->mPrimaryCursorPosition, + cursorInfo ); if( mEventData->mScrollAfterUpdatePosition ) { - const Vector2& primaryCursorPosition = mEventData->mDecorator->GetPosition( PRIMARY_CURSOR ); - - ScrollToMakePositionVisible( primaryCursorPosition ); + ScrollToMakePositionVisible( cursorInfo.primaryPosition ); mEventData->mScrollAfterUpdatePosition = false; } + else if( mEventData->mScrollAfterDelete ) + { + ScrollTextToMatchCursor( cursorInfo ); + mEventData->mScrollAfterDelete = false; + } + + UpdateCursorPosition( cursorInfo ); mEventData->mDecoratorUpdated = true; mEventData->mUpdateCursorPosition = false; } - else if( mEventData->mScrollAfterDelete ) - { - ScrollTextToMatchCursor(); - mEventData->mDecoratorUpdated = true; - mEventData->mScrollAfterDelete = false; - } else { bool leftScroll = false; bool rightScroll = false; + CursorInfo leftHandleInfo; + CursorInfo rightHandleInfo; + if( mEventData->mUpdateLeftSelectionPosition ) { - UpdateSelectionHandle( LEFT_SELECTION_HANDLE ); + GetCursorPosition( mEventData->mLeftSelectionPosition, + leftHandleInfo ); if( mEventData->mScrollAfterUpdatePosition ) { - const Vector2& leftHandlePosition = mEventData->mDecorator->GetPosition( LEFT_SELECTION_HANDLE ); - - ScrollToMakePositionVisible( leftHandlePosition ); + ScrollToMakePositionVisible( leftHandleInfo.primaryPosition ); leftScroll = true; } - - SetPopupButtons(); - mEventData->mDecoratorUpdated = true; - mEventData->mUpdateLeftSelectionPosition = false; } if( mEventData->mUpdateRightSelectionPosition ) { - UpdateSelectionHandle( RIGHT_SELECTION_HANDLE ); + GetCursorPosition( mEventData->mRightSelectionPosition, + rightHandleInfo ); if( mEventData->mScrollAfterUpdatePosition ) { - const Vector2& rightHandlePosition = mEventData->mDecorator->GetPosition( RIGHT_SELECTION_HANDLE ); - - ScrollToMakePositionVisible( rightHandlePosition ); + ScrollToMakePositionVisible( rightHandleInfo.primaryPosition ); rightScroll = true; } + } + + if( mEventData->mUpdateLeftSelectionPosition ) + { + UpdateSelectionHandle( LEFT_SELECTION_HANDLE, + leftHandleInfo ); SetPopupButtons(); mEventData->mDecoratorUpdated = true; + } + + if( mEventData->mUpdateRightSelectionPosition ) + { + UpdateSelectionHandle( RIGHT_SELECTION_HANDLE, + rightHandleInfo ); + + SetPopupButtons(); + mEventData->mDecoratorUpdated = true; + } + + if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition ) + { + RepositionSelectionHandles(); + + mEventData->mUpdateLeftSelectionPosition = false; mEventData->mUpdateRightSelectionPosition = false; } @@ -283,6 +296,8 @@ bool Controller::Impl::ProcessInputEvents() void 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 ); @@ -329,7 +344,6 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) { // Retrieves the scripts used in the text. multilanguageSupport.SetScripts( utf32Characters, - lineBreakInfo, scripts ); } @@ -352,13 +366,12 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) Vector mirroredUtf32Characters; bool textMirrored = false; + Length numberOfParagraphs = 0u; if( BIDI_INFO & operations ) { // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's // bidirectional info. - Length numberOfParagraphs = 0u; - const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin(); for( Length index = 0u; index < numberOfCharacters; ++index ) { @@ -382,7 +395,9 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) // This paragraph has right to left text. Some characters may need to be mirrored. // TODO: consider if the mirrored string can be stored as well. - textMirrored = GetMirroredText( utf32Characters, mirroredUtf32Characters ); + textMirrored = GetMirroredText( utf32Characters, + mirroredUtf32Characters, + bidirectionalInfo ); // Only set the character directions if there is right to left characters. Vector& directions = mLogicalModel->mCharacterDirections; @@ -396,12 +411,14 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) // There is no right to left characters. Clear the directions vector. mLogicalModel->mCharacterDirections.Clear(); } - - } + } Vector& glyphs = mVisualModel->mGlyphs; Vector& glyphsToCharactersMap = mVisualModel->mGlyphsToCharacters; Vector& charactersPerGlyph = mVisualModel->mCharactersPerGlyph; + Vector newParagraphGlyphs; + newParagraphGlyphs.Reserve( numberOfParagraphs ); + if( SHAPE_TEXT & operations ) { const Vector& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters; @@ -412,7 +429,8 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) validFonts, glyphs, glyphsToCharactersMap, - charactersPerGlyph ); + charactersPerGlyph, + newParagraphGlyphs ); // Create the 'number of glyphs' per character and the glyph to character conversion tables. mVisualModel->CreateGlyphsPerCharacterTable( numberOfCharacters ); @@ -423,7 +441,40 @@ void Controller::Impl::UpdateModel( OperationsMask operationsRequired ) if( GET_GLYPH_METRICS & operations ) { - mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs ); + GlyphInfo* glyphsBuffer = glyphs.Begin(); + mMetrics->GetGlyphMetrics( glyphsBuffer, numberOfGlyphs ); + + // Update the width and advance of all new paragraph characters. + for( Vector::ConstIterator it = newParagraphGlyphs.Begin(), endIt = newParagraphGlyphs.End(); it != endIt; ++it ) + { + const GlyphIndex index = *it; + GlyphInfo& glyph = *( glyphsBuffer + index ); + + glyph.xBearing = 0.f; + glyph.width = 0.f; + glyph.advance = 0.f; + } + } + + if( mEventData && + mEventData->mPreEditFlag && + ( 0u != mVisualModel->mCharactersToGlyph.Count() ) ) + { + // Add the underline for the pre-edit text. + const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); + const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); + + const GlyphIndex glyphStart = *( charactersToGlyphBuffer + mEventData->mPreEditStartPosition ); + const CharacterIndex lastPreEditCharacter = mEventData->mPreEditStartPosition + ( ( mEventData->mPreEditLength > 0u ) ? mEventData->mPreEditLength - 1u : 0u ); + const Length numberOfGlyphsLastCharacter = *( glyphsPerCharacterBuffer + lastPreEditCharacter ); + const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + lastPreEditCharacter ) + ( numberOfGlyphsLastCharacter > 1u ? numberOfGlyphsLastCharacter - 1u : 0u ); + + GlyphRun underlineRun; + underlineRun.glyphIndex = glyphStart; + underlineRun.numberOfGlyphs = 1u + glyphEnd - glyphStart; + + // TODO: At the moment the underline runs are only for pre-edit. + mVisualModel->mUnderlineRuns.PushBack( underlineRun ); } } @@ -431,6 +482,7 @@ void Controller::Impl::GetDefaultFonts( Vector& fonts, Length numberOfC { if( mFontDefaults ) { + DALI_LOG_INFO( gLogFilter, Debug::Concise, "Controller::GetDefaultFonts font family(%s)\n", mFontDefaults->mFontDescription.family.c_str() ); FontRun fontRun; fontRun.characterRun.characterIndex = 0; fontRun.characterRun.numberOfCharacters = numberOfCharacters; @@ -446,8 +498,8 @@ float Controller::Impl::GetDefaultFontLineHeight() FontId defaultFontId = 0u; if( NULL == mFontDefaults ) { - defaultFontId = mFontClient.GetFontId( EMPTY_STRING, - EMPTY_STRING ); + TextAbstraction::FontDescription fontDescription; + defaultFontId = mFontClient.GetFontId( fontDescription ); } else { @@ -455,7 +507,7 @@ float Controller::Impl::GetDefaultFontLineHeight() } Text::FontMetrics fontMetrics; - mFontClient.GetFontMetrics( defaultFontId, fontMetrics ); + mMetrics->GetFontMetrics( defaultFontId, fontMetrics ); return( fontMetrics.ascender - fontMetrics.descender ); } @@ -505,13 +557,16 @@ void Controller::Impl::OnTapEvent( const Event& event ) if( 1u == tapCount ) { - if( ! IsShowingPlaceholderText() ) + if( IsShowingRealText() ) { 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 ); + + // When the cursor position is changing, delay cursor blinking + mEventData->mDecorator->DelayCursorBlink(); } else { @@ -610,9 +665,6 @@ void Controller::Impl::OnHandleEvent( const Event& event ) { mEventData->mLeftSelectionPosition = handleNewPosition; - RepositionSelectionHandles( mEventData->mLeftSelectionPosition, - mEventData->mRightSelectionPosition ); - mEventData->mUpdateLeftSelectionPosition = true; } } @@ -625,9 +677,6 @@ void Controller::Impl::OnHandleEvent( const Event& event ) { mEventData->mRightSelectionPosition = handleNewPosition; - RepositionSelectionHandles( mEventData->mLeftSelectionPosition, - mEventData->mRightSelectionPosition ); - mEventData->mUpdateRightSelectionPosition = true; } } @@ -669,9 +718,6 @@ void Controller::Impl::OnHandleEvent( const Event& event ) if( mEventData->mUpdateLeftSelectionPosition ) { mEventData->mLeftSelectionPosition = handlePosition; - - RepositionSelectionHandles( mEventData->mLeftSelectionPosition, - mEventData->mRightSelectionPosition ); } } } @@ -686,8 +732,6 @@ void Controller::Impl::OnHandleEvent( const Event& event ) if( mEventData->mUpdateRightSelectionPosition ) { mEventData->mRightSelectionPosition = handlePosition; - RepositionSelectionHandles( mEventData->mLeftSelectionPosition, - mEventData->mRightSelectionPosition ); } } } @@ -726,7 +770,7 @@ void Controller::Impl::OnHandleEvent( const Event& event ) Vector2 position = mEventData->mDecorator->GetPosition( GRAB_HANDLE ); // Position the grag handle close to either the left or right edge. - position.x = scrollRightDirection ? 0.f : mControlSize.width; + position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width; // Get the new handle position. // The grab handle's position is in decorator coords. Need to transforms to text coords. @@ -747,7 +791,7 @@ void Controller::Impl::OnHandleEvent( const Event& event ) Vector2 position = mEventData->mDecorator->GetPosition( leftSelectionHandleEvent ? Text::LEFT_SELECTION_HANDLE : Text::RIGHT_SELECTION_HANDLE ); // Position the selection handle close to either the left or right edge. - position.x = scrollRightDirection ? 0.f : mControlSize.width; + position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width; // Get the new handle position. // The selection handle's position is in decorator coords. Need to transforms to text coords. @@ -775,8 +819,7 @@ void Controller::Impl::OnHandleEvent( const Event& event ) if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition ) { - RepositionSelectionHandles( mEventData->mLeftSelectionPosition, - mEventData->mRightSelectionPosition ); + RepositionSelectionHandles(); mEventData->mScrollAfterUpdatePosition = true; } @@ -799,17 +842,14 @@ void Controller::Impl::OnSelectEvent( 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 leftPosition = mEventData->mLeftSelectionPosition; - const CharacterIndex rightPosition = mEventData->mRightSelectionPosition; - + // Calculates the logical position from the x,y coords. RepositionSelectionHandles( xPosition, yPosition ); - mEventData->mUpdateLeftSelectionPosition = leftPosition != mEventData->mLeftSelectionPosition; - mEventData->mUpdateRightSelectionPosition = rightPosition != mEventData->mRightSelectionPosition; + mEventData->mUpdateLeftSelectionPosition = true; + mEventData->mUpdateRightSelectionPosition = true; - mEventData->mScrollAfterUpdatePosition = ( ( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition ) && - ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition ) ); + mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition ); } } @@ -823,8 +863,8 @@ void Controller::Impl::OnSelectAllEvent() if( mEventData->mSelectionEnabled ) { - RepositionSelectionHandles( 0u, - mLogicalModel->mText.Count() ); + mEventData->mLeftSelectionPosition = 0u; + mEventData->mRightSelectionPosition = mLogicalModel->mText.Count(); mEventData->mScrollAfterUpdatePosition = true; mEventData->mUpdateLeftSelectionPosition = true; @@ -841,12 +881,14 @@ void Controller::Impl::RetrieveSelection( std::string& selectedText, bool delete return; } + const bool handlesCrossed = mEventData->mLeftSelectionPosition > mEventData->mRightSelectionPosition; + //Get start and end position of selection - uint32_t startOfSelectedText = mEventData->mLeftSelectionPosition; - uint32_t lengthOfSelectedText = mEventData->mRightSelectionPosition - startOfSelectedText; + uint32_t startOfSelectedText = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition; + uint32_t lengthOfSelectedText = ( handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition ) - startOfSelectedText; // Validate the start and end selection points - if( ( startOfSelectedText >= 0 ) && ( ( startOfSelectedText + lengthOfSelectedText ) <= mLogicalModel->mText.Count() ) ) + if( ( startOfSelectedText + lengthOfSelectedText ) <= mLogicalModel->mText.Count() ) { //Get text as a UTF8 string Vector& utf32Characters = mLogicalModel->mText; @@ -861,9 +903,15 @@ void Controller::Impl::RetrieveSelection( std::string& selectedText, bool delete Vector::Iterator first = currentText.Begin() + startOfSelectedText; Vector::Iterator last = first + lengthOfSelectedText; currentText.Erase( first, last ); + + // Scroll after delete. + mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition; + mEventData->mScrollAfterDelete = true; } - mEventData->mPrimaryCursorPosition = mEventData->mLeftSelectionPosition; - mEventData->mScrollAfterDelete = true; + // Udpade the cursor position and the decorator. + // Scroll after the position is updated if is not scrolling after delete. + mEventData->mUpdateCursorPosition = true; + mEventData->mScrollAfterUpdatePosition = !mEventData->mScrollAfterDelete; mEventData->mDecoratorUpdated = true; } } @@ -906,8 +954,11 @@ void Controller::Impl::GetTextFromClipboard( unsigned int itemIndex, std::string } } -void Controller::Impl::RepositionSelectionHandles( CharacterIndex selectionStart, CharacterIndex selectionEnd ) +void Controller::Impl::RepositionSelectionHandles() { + CharacterIndex selectionStart = mEventData->mLeftSelectionPosition; + CharacterIndex selectionEnd = mEventData->mRightSelectionPosition; + if( selectionStart == selectionEnd ) { // Nothing to select if handles are in the same place. @@ -916,43 +967,117 @@ void Controller::Impl::RepositionSelectionHandles( CharacterIndex selectionStart mEventData->mDecorator->ClearHighlights(); - mEventData->mLeftSelectionPosition = selectionStart; - mEventData->mRightSelectionPosition = selectionEnd; - const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); const GlyphInfo* const glyphsBuffer = mVisualModel->mGlyphs.Begin(); const Vector2* const positionsBuffer = mVisualModel->mGlyphPositions.Begin(); + const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); + const CharacterIndex* const glyphToCharacterBuffer = mVisualModel->mGlyphsToCharacters.Begin(); + const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL; // TODO: Better algorithm to create the highlight box. // TODO: Multi-line. + // Get the height of the line. const Vector& lines = mVisualModel->mLines; const LineRun& firstLine = *lines.Begin(); const float height = firstLine.ascender + -firstLine.descender; - const bool indicesSwapped = ( selectionStart > selectionEnd ); + const bool isLastCharacter = selectionEnd >= mLogicalModel->mText.Count(); + const bool startDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + selectionStart ) ); + const bool endDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + ( selectionEnd - ( isLastCharacter ? 1u : 0u ) ) ) ); + + // Swap the indices if the start is greater than the end. + const bool indicesSwapped = selectionStart > selectionEnd; + + // Tell the decorator to flip the selection handles if needed. + mEventData->mDecorator->SetSelectionHandleFlipState( indicesSwapped, startDirection, endDirection ); + if( indicesSwapped ) { std::swap( selectionStart, selectionEnd ); } + // Get the indices to the first and last selected glyphs. + const CharacterIndex selectionEndMinusOne = selectionEnd - 1u; const GlyphIndex glyphStart = *( charactersToGlyphBuffer + selectionStart ); - const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + ( selectionEnd - 1u ) ); - const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + ( selectionEnd - 1u ) ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u ); + const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + selectionEndMinusOne ); + const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + selectionEndMinusOne ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u ); + + // Check if the first glyph is a ligature that must be broken like Latin ff, fi, or Arabic ï»», etc which needs special code. + const Length numberOfCharactersStart = *( charactersPerGlyphBuffer + glyphStart ); + bool splitStartGlyph = ( numberOfCharactersStart > 1u ) && HasLigatureMustBreak( mLogicalModel->GetScript( selectionStart ) ); - mEventData->mDecorator->SwapSelectionHandlesEnabled( firstLine.direction != indicesSwapped ); + // Check if the last glyph is a ligature that must be broken like Latin ff, fi, or Arabic ï»», etc which needs special code. + const Length numberOfCharactersEnd = *( charactersPerGlyphBuffer + glyphEnd ); + bool splitEndGlyph = ( glyphStart != glyphEnd ) && ( numberOfCharactersEnd > 1u ) && HasLigatureMustBreak( mLogicalModel->GetScript( selectionEndMinusOne ) ); const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset; + // Traverse the glyphs. for( GlyphIndex index = glyphStart; index <= glyphEnd; ++index ) { - // TODO: Fix the LATIN ligatures. i.e ff, fi, etc... const GlyphInfo& glyph = *( glyphsBuffer + index ); const Vector2& position = *( positionsBuffer + index ); + if( splitStartGlyph ) + { + // If the first glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box. + + const float glyphAdvance = glyph.advance / static_cast( numberOfCharactersStart ); + const CharacterIndex interGlyphIndex = selectionStart - *( glyphToCharacterBuffer + glyphStart ); + // Get the direction of the character. + CharacterDirection isCurrentRightToLeft = false; + if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right. + { + isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionStart ); + } + + // The end point could be in the middle of the ligature. + // Calculate the number of characters selected. + const Length numberOfCharacters = ( glyphStart == glyphEnd ) ? ( selectionEnd - selectionStart ) : ( numberOfCharactersStart - interGlyphIndex ); + + const float xPosition = position.x - glyph.xBearing + offset.x + glyphAdvance * static_cast( isCurrentRightToLeft ? ( numberOfCharactersStart - interGlyphIndex - numberOfCharacters ) : interGlyphIndex ); + + mEventData->mDecorator->AddHighlight( xPosition, + offset.y, + xPosition + static_cast( numberOfCharacters ) * glyphAdvance, + offset.y + height ); + + splitStartGlyph = false; + continue; + } + + if( splitEndGlyph && ( index == glyphEnd ) ) + { + // Equally, if the last glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box. + + const float glyphAdvance = glyph.advance / static_cast( numberOfCharactersEnd ); + const CharacterIndex interGlyphIndex = selectionEnd - *( glyphToCharacterBuffer + glyphEnd ); + // Get the direction of the character. + CharacterDirection isCurrentRightToLeft = false; + if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right. + { + isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionEnd ); + } + + const Length numberOfCharacters = numberOfCharactersEnd - interGlyphIndex; + + const float xPosition = position.x - glyph.xBearing + offset.x + ( isCurrentRightToLeft ? ( glyphAdvance * static_cast( numberOfCharacters ) ) : 0.f ); + mEventData->mDecorator->AddHighlight( xPosition, + offset.y, + xPosition + static_cast( interGlyphIndex ) * glyphAdvance, + offset.y + height ); + + splitEndGlyph = false; + continue; + } + const float xPosition = position.x - glyph.xBearing + offset.x; - mEventData->mDecorator->AddHighlight( xPosition, offset.y, xPosition + glyph.advance, height ); + mEventData->mDecorator->AddHighlight( xPosition, + offset.y, + xPosition + glyph.advance, + offset.y + height ); } CursorInfo primaryCursorInfo; @@ -970,6 +1095,9 @@ void Controller::Impl::RepositionSelectionHandles( CharacterIndex selectionStart mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE, secondaryPosition.x, secondaryPosition.y, secondaryCursorInfo.lineHeight ); + // Cursor to be positioned at end of selection so if selection interrupted and edit mode restarted the cursor will be at end of selection + mEventData->mPrimaryCursorPosition = ( indicesSwapped ) ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition; + // Set the flag to update the decorator. mEventData->mDecoratorUpdated = true; } @@ -1010,7 +1138,8 @@ void Controller::Impl::RepositionSelectionHandles( float visualX, float visualY return; } - RepositionSelectionHandles( selectionStart, selectionEnd ); + mEventData->mLeftSelectionPosition = selectionStart; + mEventData->mRightSelectionPosition = selectionEnd; } void Controller::Impl::SetPopupButtons() @@ -1025,7 +1154,7 @@ void Controller::Impl::SetPopupButtons() TextSelectionPopup::Buttons buttonsToShow = TextSelectionPopup::NONE; - if ( ( EventData::SELECTING == mEventData->mState ) || ( EventData::SELECTION_CHANGED == mEventData->mState ) ) + if( EventData::SELECTING == mEventData->mState ) { buttonsToShow = TextSelectionPopup::Buttons( TextSelectionPopup::CUT | TextSelectionPopup::COPY ); @@ -1103,16 +1232,6 @@ void Controller::Impl::ChangeState( EventData::State newState ) } mEventData->mDecoratorUpdated = true; } - else if ( EventData::SELECTION_CHANGED == mEventData->mState ) - { - if( mEventData->mGrabHandlePopupEnabled ) - { - SetPopupButtons(); - mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE ); - mEventData->mDecorator->SetPopupActive( true ); - } - mEventData->mDecoratorUpdated = true; - } else if( EventData::EDITING == mEventData->mState ) { mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY ); @@ -1234,10 +1353,25 @@ LineIndex Controller::Impl::GetClosestLine( float y ) const 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() ) { - // Selection out of bounds. - return; + // 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; @@ -1269,6 +1403,8 @@ void Controller::Impl::FindSelectionIndices( float visualX, float visualY, Chara 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. @@ -1302,7 +1438,6 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX, // Get the glyphs per character table. const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin(); - const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); // If the vector is void, there is no right to left characters. const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer; @@ -1316,6 +1451,7 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX, // 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. @@ -1324,44 +1460,59 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX, // Get the script of the character. const Script script = mLogicalModel->GetScript( characterLogicalOrderIndex ); - // The first glyph for that character in logical order. - const GlyphIndex glyphLogicalOrderIndex = *( charactersToGlyphBuffer + characterLogicalOrderIndex ); // The number of glyphs for that character const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex ); + ++numberOfCharacters; - // Get the metrics for the group of glyphs. - GlyphMetrics glyphMetrics; - GetGlyphsMetrics( glyphLogicalOrderIndex, - numberOfGlyphs, - glyphMetrics, - mVisualModel, - mFontClient ); - - const Vector2& position = *( positionsBuffer + glyphLogicalOrderIndex ); - // Prevents to jump the whole Latin ligatures like fi, ff, ... - const Length numberOfCharactersInLigature = ( TextAbstraction::LATIN == script ) ? *( charactersPerGlyphBuffer + glyphLogicalOrderIndex ) : 1u; - const float glyphAdvance = glyphMetrics.advance / static_cast( numberOfCharactersInLigature ); - - for( GlyphIndex index = 0u; !matched && ( index < numberOfCharactersInLigature ); ++index ) + if( 0u != numberOfGlyphs ) { - // Find the mid-point of the area containing the glyph - const float glyphCenter = -glyphMetrics.xBearing + position.x + ( static_cast( index ) + 0.5f ) * glyphAdvance; + // 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 ) + if( visualX < glyphCenter ) + { + matched = true; + break; + } + } + + if( matched ) { - visualIndex += index; - matched = true; + visualIndex = firstVisualCharacterIndex + index; break; } - } - if( matched ) - { - break; + numberOfCharacters = 0u; } + } + // Return the logical position of the cursor in characters. if( !matched ) @@ -1372,6 +1523,8 @@ CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX, 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; } @@ -1380,23 +1533,64 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, { // TODO: Check for multiline with \n, etc... - // Check if the logical position is the first or the last one of the text. - const bool isFirstPosition = 0u == logical; - const bool isLastPosition = mLogicalModel->mText.Count() == logical; - - if( isFirstPosition && isLastPosition ) + const Length numberOfCharacters = mLogicalModel->mText.Count(); + if( !IsShowingRealText() ) { - // There is zero characters. Get the default font's line height. + // Do not want to use the place-holder text to set the cursor position. + + // Use the line's height of the font's family set to set the cursor's size. + // If there is no font's family set, use the default font. + // Use the current alignment to place the cursor at the beginning, center or end of the box. + cursorInfo.lineHeight = GetDefaultFontLineHeight(); cursorInfo.primaryCursorHeight = cursorInfo.lineHeight; - cursorInfo.primaryPosition.x = 1.f; - cursorInfo.primaryPosition.y = 0.f; + switch( mLayoutEngine.GetHorizontalAlignment() ) + { + case LayoutEngine::HORIZONTAL_ALIGN_BEGIN: + { + cursorInfo.primaryPosition.x = 0.f; + break; + } + case LayoutEngine::HORIZONTAL_ALIGN_CENTER: + { + cursorInfo.primaryPosition.x = floorf( 0.5f * mVisualModel->mControlSize.width ); + break; + } + case LayoutEngine::HORIZONTAL_ALIGN_END: + { + cursorInfo.primaryPosition.x = mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth(); + break; + } + } + + switch( mLayoutEngine.GetVerticalAlignment() ) + { + case LayoutEngine::VERTICAL_ALIGN_TOP: + { + cursorInfo.primaryPosition.y = 0.f; + break; + } + case LayoutEngine::VERTICAL_ALIGN_CENTER: + { + cursorInfo.primaryPosition.y = floorf( 0.5f * ( mVisualModel->mControlSize.height - cursorInfo.lineHeight ) ); + break; + } + case LayoutEngine::VERTICAL_ALIGN_BOTTOM: + { + cursorInfo.primaryPosition.y = mVisualModel->mControlSize.height - cursorInfo.lineHeight; + break; + } + } // Nothing else to do. 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; @@ -1414,7 +1608,7 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, } // Get the line where the character is laid-out. - const LineRun* modelLines = mVisualModel->mLines.Begin(); + const LineRun* const modelLines = mVisualModel->mLines.Begin(); const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( characterIndex ); const LineRun& line = *( modelLines + lineIndex ); @@ -1455,10 +1649,16 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, } } + 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 = *( mVisualModel->mCharactersToGlyph.Begin() + index ); - const Length primaryNumberOfGlyphs = *( mVisualModel->mGlyphsPerCharacter.Begin() + index ); - const Length primaryNumberOfCharacters = *( mVisualModel->mCharactersPerGlyph.Begin() + primaryGlyphIndex ); + 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; @@ -1466,35 +1666,72 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, primaryNumberOfGlyphs, glyphMetrics, mVisualModel, - mFontClient ); + 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; - float glyphAdvance = 0.f; if( !isLastPosition && ( primaryNumberOfCharacters > 1u ) ) { - const CharacterIndex firstIndex = *( mVisualModel->mGlyphsToCharacters.Begin() + primaryGlyphIndex ); - glyphAdvance = static_cast( 1u + characterIndex - firstIndex ) * glyphMetrics.advance / static_cast( primaryNumberOfCharacters ); - } - else - { - glyphAdvance = glyphMetrics.advance; + 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 = *( mVisualModel->mGlyphPositions.Begin() + primaryGlyphIndex ); + 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. - if( isLastPosition ) - { - cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + primaryPosition.x + ( isRightToLeftParagraph ? 0.f : glyphMetrics.advance ); - } - else - { - cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + primaryPosition.x + ( ( ( isFirstPosition && !isCurrentRightToLeft ) || ( !isFirstPosition && isCurrentRightToLeft ) ) ? 0.f : glyphAdvance ); - } + cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + primaryPosition.x + glyphAdvance; cursorInfo.primaryPosition.y = line.ascender - glyphMetrics.ascender; // Calculate the secondary cursor. @@ -1510,16 +1747,16 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical, index = ( isRightToLeftParagraph == isCurrentRightToLeft ) ? nextCharacterIndex : characterIndex; } - const GlyphIndex secondaryGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + index ); - const Length secondaryNumberOfGlyphs = *( mVisualModel->mGlyphsPerCharacter.Begin() + index ); + const GlyphIndex secondaryGlyphIndex = *( charactersToGlyphBuffer + index ); + const Length secondaryNumberOfGlyphs = *( glyphsPerCharacterBuffer + index ); - const Vector2& secondaryPosition = *( mVisualModel->mGlyphPositions.Begin() + index ); + const Vector2& secondaryPosition = *( glyphPositionsBuffer + secondaryGlyphIndex ); GetGlyphsMetrics( secondaryGlyphIndex, secondaryNumberOfGlyphs, glyphMetrics, mVisualModel, - mFontClient ); + mMetrics ); // Set the secondary cursor's position. cursorInfo.secondaryPosition.x = -glyphMetrics.xBearing + secondaryPosition.x + ( isCurrentRightToLeft ? 0.f : glyphMetrics.advance ); @@ -1537,25 +1774,27 @@ CharacterIndex Controller::Impl::CalculateNewCursorIndex( CharacterIndex index ) CharacterIndex cursorIndex = mEventData->mPrimaryCursorPosition; - const Script script = mLogicalModel->GetScript( index ); - const GlyphIndex* charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); - const Length* charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); + const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin(); + const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin(); + + GlyphIndex glyphIndex = *( charactersToGlyphBuffer + index ); + Length numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex ); - Length numberOfCharacters = 0u; - if( TextAbstraction::LATIN == script ) + if( numberOfCharacters > 1u ) { - // Prevents to jump the whole Latin ligatures like fi, ff, ... - numberOfCharacters = 1u; + const Script script = mLogicalModel->GetScript( index ); + if( HasLigatureMustBreak( script ) ) + { + // Prevents to jump the whole Latin ligatures like fi, ff, or Arabic ï»», ... + numberOfCharacters = 1u; + } } else { - GlyphIndex glyphIndex = *( charactersToGlyphBuffer + index ); - numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex ); - while( 0u == numberOfCharacters ) { - numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex ); ++glyphIndex; + numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex ); } } @@ -1571,7 +1810,7 @@ CharacterIndex Controller::Impl::CalculateNewCursorIndex( CharacterIndex index ) return cursorIndex; } -void Controller::Impl::UpdateCursorPosition() +void Controller::Impl::UpdateCursorPosition( const CursorInfo& cursorInfo ) { DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::UpdateCursorPosition %p\n", this ); if( NULL == mEventData ) @@ -1581,121 +1820,58 @@ void Controller::Impl::UpdateCursorPosition() return; } - if( IsShowingPlaceholderText() ) - { - // Do not want to use the place-holder text to set the cursor position. - - // Use the line's height of the font's family set to set the cursor's size. - // If there is no font's family set, use the default font. - // Use the current alignment to place the cursor at the beginning, center or end of the box. - - float lineHeight = 0.f; - - FontId defaultFontId = 0u; - if( NULL == mFontDefaults ) - { - defaultFontId = mFontClient.GetFontId( EMPTY_STRING, - EMPTY_STRING ); - } - else - { - defaultFontId = mFontDefaults->GetFontId( mFontClient ); - } - - Text::FontMetrics fontMetrics; - mFontClient.GetFontMetrics( defaultFontId, fontMetrics ); - - lineHeight = fontMetrics.ascender - fontMetrics.descender; - - - Vector2 cursorPosition; + const Vector2 offset = mEventData->mScrollPosition + ( IsShowingRealText() ? mAlignmentOffset : Vector2::ZERO ); + const Vector2 cursorPosition = cursorInfo.primaryPosition + offset; - switch( mLayoutEngine.GetHorizontalAlignment() ) - { - case LayoutEngine::HORIZONTAL_ALIGN_BEGIN: - { - cursorPosition.x = 1.f; - break; - } - case LayoutEngine::HORIZONTAL_ALIGN_CENTER: - { - cursorPosition.x = floor( 0.5f * mControlSize.width ); - break; - } - case LayoutEngine::HORIZONTAL_ALIGN_END: - { - cursorPosition.x = mControlSize.width; - break; - } - } + // Sets the cursor position. + mEventData->mDecorator->SetPosition( PRIMARY_CURSOR, + cursorPosition.x, + cursorPosition.y, + cursorInfo.primaryCursorHeight, + cursorInfo.lineHeight ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y ); - switch( mLayoutEngine.GetVerticalAlignment() ) - { - case LayoutEngine::VERTICAL_ALIGN_TOP: - { - cursorPosition.y = 0.f; - break; - } - case LayoutEngine::VERTICAL_ALIGN_CENTER: - { - cursorPosition.y = floorf( 0.5f * ( mControlSize.height - lineHeight ) ); - break; - } - case LayoutEngine::VERTICAL_ALIGN_BOTTOM: - { - cursorPosition.y = mControlSize.height - lineHeight; - break; - } - } + // Sets the grab handle position. + mEventData->mDecorator->SetPosition( GRAB_HANDLE, + cursorPosition.x, + cursorPosition.y, + cursorInfo.lineHeight ); - mEventData->mDecorator->SetPosition( PRIMARY_CURSOR, - cursorPosition.x, - cursorPosition.y, - lineHeight, - lineHeight ); - } - else + if( cursorInfo.isSecondaryCursor ) { - CursorInfo cursorInfo; - GetCursorPosition( mEventData->mPrimaryCursorPosition, - cursorInfo ); - - const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset; - const Vector2 cursorPosition = cursorInfo.primaryPosition + offset; - - // Sets the cursor position. - mEventData->mDecorator->SetPosition( PRIMARY_CURSOR, - cursorPosition.x, - cursorPosition.y, - cursorInfo.primaryCursorHeight, - cursorInfo.lineHeight ); - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y ); - - // Sets the grab handle position. - mEventData->mDecorator->SetPosition( GRAB_HANDLE, - cursorPosition.x, - cursorPosition.y, + mEventData->mDecorator->SetPosition( SECONDARY_CURSOR, + cursorInfo.secondaryPosition.x + offset.x, + cursorInfo.secondaryPosition.y + offset.y, + cursorInfo.secondaryCursorHeight, cursorInfo.lineHeight ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + offset.x, cursorInfo.secondaryPosition.y + offset.y ); + } + // Set which cursors are active according the state. + if( ( EventData::EDITING == mEventData->mState ) || + ( EventData::EDITING_WITH_POPUP == mEventData->mState ) || + ( EventData::EDITING_WITH_GRAB_HANDLE == mEventData->mState ) || + ( EventData::GRAB_HANDLE_PANNING == mEventData->mState ) ) + { if( cursorInfo.isSecondaryCursor ) { mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_BOTH ); - mEventData->mDecorator->SetPosition( SECONDARY_CURSOR, - cursorInfo.secondaryPosition.x + offset.x, - cursorInfo.secondaryPosition.y + offset.y, - cursorInfo.secondaryCursorHeight, - cursorInfo.lineHeight ); - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + offset.x, cursorInfo.secondaryPosition.y + offset.y ); } else { mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY ); } } + else + { + mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE ); + } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition\n" ); } -void Controller::Impl::UpdateSelectionHandle( HandleType handleType ) +void Controller::Impl::UpdateSelectionHandle( HandleType handleType, + const CursorInfo& cursorInfo ) { if( ( LEFT_SELECTION_HANDLE != handleType ) && ( RIGHT_SELECTION_HANDLE != handleType ) ) @@ -1703,15 +1879,7 @@ void Controller::Impl::UpdateSelectionHandle( HandleType handleType ) return; } - const bool leftSelectionHandle = LEFT_SELECTION_HANDLE == handleType; - const CharacterIndex index = leftSelectionHandle ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition; - - CursorInfo cursorInfo; - GetCursorPosition( index, - cursorInfo ); - - const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset; - const Vector2 cursorPosition = cursorInfo.primaryPosition + offset; + const Vector2 cursorPosition = cursorInfo.primaryPosition + mEventData->mScrollPosition + mAlignmentOffset; // Sets the grab handle position. mEventData->mDecorator->SetPosition( handleType, @@ -1728,9 +1896,10 @@ void Controller::Impl::UpdateSelectionHandle( HandleType handleType ) void Controller::Impl::ClampHorizontalScroll( const Vector2& actualSize ) { // Clamp between -space & 0 (and the text alignment). - if( actualSize.width > mControlSize.width ) + + if( actualSize.width > mVisualModel->mControlSize.width ) { - const float space = ( actualSize.width - mControlSize.width ) + mAlignmentOffset.x; + const float space = ( actualSize.width - mVisualModel->mControlSize.width ) + mAlignmentOffset.x; mEventData->mScrollPosition.x = ( mEventData->mScrollPosition.x < -space ) ? -space : mEventData->mScrollPosition.x; mEventData->mScrollPosition.x = ( mEventData->mScrollPosition.x > -mAlignmentOffset.x ) ? -mAlignmentOffset.x : mEventData->mScrollPosition.x; @@ -1745,9 +1914,9 @@ void Controller::Impl::ClampHorizontalScroll( const Vector2& actualSize ) void Controller::Impl::ClampVerticalScroll( const Vector2& actualSize ) { // Clamp between -space & 0 (and the text alignment). - if( actualSize.height > mControlSize.height ) + if( actualSize.height > mVisualModel->mControlSize.height ) { - const float space = ( actualSize.height - mControlSize.height ) + mAlignmentOffset.y; + const float space = ( actualSize.height - mVisualModel->mControlSize.height ) + mAlignmentOffset.y; mEventData->mScrollPosition.y = ( mEventData->mScrollPosition.y < -space ) ? -space : mEventData->mScrollPosition.y; mEventData->mScrollPosition.y = ( mEventData->mScrollPosition.y > -mAlignmentOffset.y ) ? -mAlignmentOffset.y : mEventData->mScrollPosition.y; @@ -1761,88 +1930,33 @@ void Controller::Impl::ClampVerticalScroll( const Vector2& actualSize ) void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position ) { - Vector2 offset; - bool updateDecorator = false; - if( position.x < 0.f ) - { - offset.x = -position.x; - mEventData->mScrollPosition.x += offset.x; - updateDecorator = true; - } - else if( position.x > mControlSize.width ) + // position is in actor's coords. + 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 decoratorPositionBegin = position.x + offset; + const float decoratorPositionEnd = positionEnd + offset; + + if( decoratorPositionBegin < 0.f ) { - offset.x = mControlSize.width - position.x; - mEventData->mScrollPosition.x += offset.x; - updateDecorator = true; + mEventData->mScrollPosition.x = -position.x - mAlignmentOffset.x; } - - if( updateDecorator && mEventData->mDecorator ) + else if( decoratorPositionEnd > mVisualModel->mControlSize.width ) { - mEventData->mDecorator->UpdatePositions( offset ); + mEventData->mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd - mAlignmentOffset.x; } - - // TODO : calculate the vertical scroll. } -void Controller::Impl::ScrollTextToMatchCursor() +void Controller::Impl::ScrollTextToMatchCursor( const CursorInfo& cursorInfo ) { // Get the current cursor position in decorator coords. const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition( PRIMARY_CURSOR ); - // Calculate the new cursor position. - CursorInfo cursorInfo; - GetCursorPosition( mEventData->mPrimaryCursorPosition, - 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() ); - - const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset; - const Vector2 cursorPosition = cursorInfo.primaryPosition + offset; - - // Sets the cursor position. - mEventData->mDecorator->SetPosition( PRIMARY_CURSOR, - cursorPosition.x, - cursorPosition.y, - cursorInfo.primaryCursorHeight, - cursorInfo.lineHeight ); - - // Sets the grab handle position. - mEventData->mDecorator->SetPosition( GRAB_HANDLE, - cursorPosition.x, - cursorPosition.y, - cursorInfo.lineHeight ); - - if( cursorInfo.isSecondaryCursor ) - { - mEventData->mDecorator->SetPosition( SECONDARY_CURSOR, - cursorInfo.secondaryPosition.x + offset.x, - cursorInfo.secondaryPosition.y + offset.y, - cursorInfo.secondaryCursorHeight, - cursorInfo.lineHeight ); - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + offset.x, cursorInfo.secondaryPosition.y + offset.y ); - } - - // Set which cursors are active according the state. - if( ( EventData::EDITING == mEventData->mState ) || - ( EventData::EDITING_WITH_POPUP == mEventData->mState ) || - ( EventData::GRAB_HANDLE_PANNING == mEventData->mState ) ) - { - if( cursorInfo.isSecondaryCursor ) - { - mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_BOTH ); - } - else - { - mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY ); - } - } - else - { - mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE ); - } } void Controller::Impl::RequestRelayout()