X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Fcursor-helper-functions.cpp;h=b847996aecbdace15c1bfae3b11ef49a79fdd6a0;hb=9d8c0bfbf6a4dfa8aa4a94f8884bc8b5989cbdbc;hp=b3b7250e163cbe8595784ad712a331ccce68c1ac;hpb=8d92a2cdf4665c1831b524af0a316208947e27c1;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/text/cursor-helper-functions.cpp b/dali-toolkit/internal/text/cursor-helper-functions.cpp index b3b7250..b847996 100644 --- a/dali-toolkit/internal/text/cursor-helper-functions.cpp +++ b/dali-toolkit/internal/text/cursor-helper-functions.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -33,6 +33,97 @@ namespace const Dali::Toolkit::Text::CharacterDirection LTR = false; ///< Left To Right direction. +struct FindWordData +{ + FindWordData( const Dali::Toolkit::Text::Character* const textBuffer, + Dali::Toolkit::Text::Length totalNumberOfCharacters, + Dali::Toolkit::Text::CharacterIndex hitCharacter, + bool isWhiteSpace, + bool isNewParagraph ) + : textBuffer( textBuffer ), + totalNumberOfCharacters( totalNumberOfCharacters ), + hitCharacter( hitCharacter ), + foundIndex( 0 ), + isWhiteSpace( isWhiteSpace ), + isNewParagraph( isNewParagraph ) + {} + + ~FindWordData() + {} + + const Dali::Toolkit::Text::Character* const textBuffer; + Dali::Toolkit::Text::Length totalNumberOfCharacters; + Dali::Toolkit::Text::CharacterIndex hitCharacter; + Dali::Toolkit::Text::CharacterIndex foundIndex; + bool isWhiteSpace : 1u; + bool isNewParagraph : 1u; +}; + +bool IsWhiteSpaceOrNewParagraph( Dali::Toolkit::Text::Character character, + bool isHitWhiteSpace, + bool isHitWhiteSpaceOrNewParagraph ) +{ + bool isWhiteSpaceOrNewParagraph = false; + if( isHitWhiteSpaceOrNewParagraph ) + { + if( isHitWhiteSpace ) + { + // Whether the current character is a white space. Note a new paragraph character is a white space as well but here is not wanted. + isWhiteSpaceOrNewParagraph = Dali::TextAbstraction::IsWhiteSpace( character ) && !Dali::TextAbstraction::IsNewParagraph( character ); + } + else + { + // Whether the current character is a new paragraph character. + isWhiteSpaceOrNewParagraph = Dali::TextAbstraction::IsNewParagraph( character ); + } + } + else + { + // Whether the current character is a white space or a new paragraph character (note the new paragraph character is a white space as well). + isWhiteSpaceOrNewParagraph = Dali::TextAbstraction::IsWhiteSpace( character ); + } + + return isWhiteSpaceOrNewParagraph; +} + +void FindStartOfWord( FindWordData& data ) +{ + const bool isHitWhiteSpaceOrNewParagraph = data.isWhiteSpace || data.isNewParagraph; + + for( data.foundIndex = data.hitCharacter; data.foundIndex > 0; --data.foundIndex ) + { + const Dali::Toolkit::Text::Character character = *( data.textBuffer + data.foundIndex - 1u ); + + const bool isWhiteSpaceOrNewParagraph = IsWhiteSpaceOrNewParagraph( character, + data.isWhiteSpace, + isHitWhiteSpaceOrNewParagraph ); + + if( isHitWhiteSpaceOrNewParagraph != isWhiteSpaceOrNewParagraph ) + { + break; + } + } +} + +void FindEndOfWord( FindWordData& data ) +{ + const bool isHitWhiteSpaceOrNewParagraph = data.isWhiteSpace || data.isNewParagraph; + + for( data.foundIndex = data.hitCharacter + 1u; data.foundIndex < data.totalNumberOfCharacters; ++data.foundIndex ) + { + const Dali::Toolkit::Text::Character character = *( data.textBuffer + data.foundIndex ); + + const bool isWhiteSpaceOrNewParagraph = IsWhiteSpaceOrNewParagraph( character, + data.isWhiteSpace, + isHitWhiteSpaceOrNewParagraph ); + + if( isHitWhiteSpaceOrNewParagraph != isWhiteSpaceOrNewParagraph ) + { + break; + } + } +} + } //namespace namespace Dali @@ -45,10 +136,17 @@ namespace Text { LineIndex GetClosestLine( VisualModelPtr visualModel, - float visualY ) + float visualY, + bool& matchedLine ) { float totalHeight = 0.f; - LineIndex lineIndex = 0u; + LineIndex lineIndex = 0; + matchedLine = false; + + if( visualY < 0.f ) + { + return 0; + } const Vector& lines = visualModel->mLines; @@ -65,16 +163,17 @@ LineIndex GetClosestLine( VisualModelPtr visualModel, if( visualY < totalHeight ) { + matchedLine = true; return lineIndex; } } - if( lineIndex == 0u ) + if( lineIndex == 0 ) { return 0; } - return lineIndex-1; + return lineIndex - 1u; } float CalculateLineOffset( const Vector& lines, @@ -101,11 +200,16 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, LogicalModelPtr logicalModel, MetricsPtr metrics, float visualX, - float visualY ) + float visualY, + CharacterHitTest::Mode mode, + bool& matchedCharacter ) { DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetClosestCursorIndex, closest visualX %f visualY %f\n", visualX, visualY ); - CharacterIndex logicalIndex = 0u; + // Whether there is a hit on a glyph. + matchedCharacter = false; + + CharacterIndex logicalIndex = 0; const Length totalNumberOfGlyphs = visualModel->mGlyphs.Count(); const Length totalNumberOfLines = visualModel->mLines.Count(); @@ -115,9 +219,19 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, return logicalIndex; } + // Whether there is a hit on a line. + bool matchedLine = false; + // Find which line is closest. const LineIndex lineIndex = Text::GetClosestLine( visualModel, - visualY ); + visualY, + matchedLine ); + + if( !matchedLine && ( CharacterHitTest::TAP == mode ) ) + { + // Return the first or the last character if the touch point doesn't hit a line. + return ( visualY < 0.f ) ? 0 : logicalModel->mText.Count(); + } // Convert from text's coords to line's coords. const LineRun& line = *( visualModel->mLines.Begin() + lineIndex ); @@ -150,12 +264,12 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, // The character's direction buffer. const CharacterDirection* const directionsBuffer = bidiLineFetched ? logicalModel->mCharacterDirections.Begin() : NULL; - // Whether there is a hit on a glyph. - bool matched = false; + // Whether the touch point if before the first glyph. + bool isBeforeFirstGlyph = false; // Traverses glyphs in visual order. To do that use the visual to logical conversion table. CharacterIndex visualIndex = startCharacter; - Length numberOfVisualCharacters = 0u; + Length numberOfVisualCharacters = 0; for( ; visualIndex < endCharacter; ++visualIndex ) { // The character in logical order. @@ -166,7 +280,7 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex ); ++numberOfVisualCharacters; - if( 0u != numberOfGlyphs ) + if( 0 != numberOfGlyphs ) { // Get the first character/glyph of the group of glyphs. const CharacterIndex firstVisualCharacterIndex = 1u + visualIndex - numberOfVisualCharacters; @@ -184,6 +298,17 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, // Get the position of the first glyph. const Vector2& position = *( positionsBuffer + firstLogicalGlyphIndex ); + if( startCharacter == visualIndex ) + { + const float glyphPosition = -glyphMetrics.xBearing + position.x; + + if( visualX < glyphPosition ) + { + isBeforeFirstGlyph = true; + break; + } + } + // Whether the glyph can be split, like Latin ligatures fi, ff or Arabic (ل + ا). Length numberOfCharacters = *( charactersPerGlyphBuffer + firstLogicalGlyphIndex ); if( direction != LTR ) @@ -193,7 +318,7 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, // number of glyphs in the table is found first. // Jump the number of characters to the next glyph is needed. - if( 0u == numberOfCharacters ) + if( 0 == numberOfCharacters ) { // TODO: This is a workaround to fix an issue with complex characters in the arabic // script like i.e. رّ or الأَبْجَدِيَّة العَرَبِيَّة @@ -207,7 +332,7 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, // Find the number of characters. for( GlyphIndex index = firstLogicalGlyphIndex + 1u; - ( 0u == numberOfCharacters ) && ( index < totalNumberOfGlyphs ) ; + ( 0 == numberOfCharacters ) && ( index < totalNumberOfGlyphs ); ++index ) { numberOfCharacters = *( charactersPerGlyphBuffer + index ); @@ -231,7 +356,7 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, const Length numberOfBlocks = isInterglyphIndex ? numberOfCharacters : 1u; const float glyphAdvance = glyphMetrics.advance / static_cast( numberOfBlocks ); - CharacterIndex index = 0u; + CharacterIndex index = 0; for( ; index < numberOfBlocks; ++index ) { // Find the mid-point of the area containing the glyph @@ -239,31 +364,39 @@ CharacterIndex GetClosestCursorIndex( VisualModelPtr visualModel, if( visualX < glyphCenter ) { - matched = true; + matchedCharacter = true; break; } } - if( matched ) + if( matchedCharacter ) { // If the glyph is shaped from more than one character, it matches the character of the glyph. visualIndex = firstVisualCharacterIndex + index; break; } - numberOfVisualCharacters = 0u; + numberOfVisualCharacters = 0; } - } + } // for characters in visual order. // The number of characters of the whole text. const Length totalNumberOfCharacters = logicalModel->mText.Count(); // Return the logical position of the cursor in characters. - if( !matched ) + if( !matchedCharacter ) { - // If no character is matched, then the last character (in visual order) of the line is used. - visualIndex = endCharacter; + if( isBeforeFirstGlyph ) + { + // If no character is matched, then the first character (in visual order) of the line is used. + visualIndex = startCharacter; + } + else + { + // If no character is matched, then the last character (in visual order) of the line is used. + visualIndex = endCharacter; + } } // Get the paragraph direction. @@ -520,7 +653,7 @@ void GetCursorPosition( VisualModelPtr visualModel, isCurrentRightToLeft = *( directionsBuffer + index ); } - Length numberOfGlyphAdvance = ( isFirstPositionOfLine ? 0u : 1u ) + characterIndex - firstIndex; + Length numberOfGlyphAdvance = ( isFirstPositionOfLine ? 0 : 1u ) + characterIndex - firstIndex; if( isCurrentRightToLeft ) { numberOfGlyphAdvance = primaryNumberOfCharacters - numberOfGlyphAdvance; @@ -587,7 +720,7 @@ void GetCursorPosition( VisualModelPtr visualModel, ( isFirstPositionOfLine && !isRightToLeftParagraph ) ); cursorInfo.secondaryPosition.x = -glyphMetrics.xBearing + secondaryPosition.x + ( addGlyphAdvance ? glyphMetrics.advance : 0.f ); - cursorInfo.secondaryPosition.y = cursorInfo.lineOffset + cursorInfo.lineHeight - cursorInfo.secondaryCursorHeight - line.descender - ( glyphMetrics.fontHeight - glyphMetrics.ascender ); + cursorInfo.secondaryPosition.y = cursorInfo.lineOffset + cursorInfo.lineHeight - cursorInfo.secondaryCursorHeight; // Transform the cursor info from line's coords to text's coords. cursorInfo.secondaryPosition.x += line.alignmentOffset; @@ -595,60 +728,140 @@ void GetCursorPosition( VisualModelPtr visualModel, } } -void FindSelectionIndices( VisualModelPtr visualModel, +bool FindSelectionIndices( VisualModelPtr visualModel, LogicalModelPtr logicalModel, MetricsPtr metrics, float visualX, float visualY, CharacterIndex& startIndex, - CharacterIndex& endIndex ) + CharacterIndex& endIndex, + CharacterIndex& noTextHitIndex ) { +/* + Hit character Select +|-------------------------------------------------------|------------------------------------------| +| On a word | The word | +| On a single white space between words | The word before or after the white space | +| On one of the multiple contiguous white spaces | The white spaces | +| On a single white space which is in the position zero | The white space and the next word | +| On a new paragraph character | The word or group of white spaces before | +|-------------------------------------------------------|------------------------------------------| +*/ + const Length totalNumberOfCharacters = logicalModel->mText.Count(); + startIndex = 0; + endIndex = 0; + noTextHitIndex = 0; + + if( 0 == totalNumberOfCharacters ) + { + // Nothing to do if the model is empty. + return false; + } + + bool matchedCharacter = false; CharacterIndex hitCharacter = Text::GetClosestCursorIndex( visualModel, logicalModel, metrics, visualX, - visualY ); - DALI_ASSERT_DEBUG( hitCharacter <= logicalModel->mText.Count() && "GetClosestCursorIndex returned out of bounds index" ); + visualY, + CharacterHitTest::TAP, + matchedCharacter ); - if( logicalModel->mText.Count() == 0 ) + if( !matchedCharacter ) { - return; // if model empty + noTextHitIndex = hitCharacter; } - if( hitCharacter >= logicalModel->mText.Count() ) + DALI_ASSERT_DEBUG( ( hitCharacter <= totalNumberOfCharacters ) && "GetClosestCursorIndex returned out of bounds index" ); + + if( hitCharacter >= totalNumberOfCharacters ) { // Closest hit character is the last character. - if( hitCharacter == logicalModel->mText.Count() ) + if( hitCharacter == totalNumberOfCharacters ) { hitCharacter--; //Hit character index set to last character in logical model } else { // hitCharacter is out of bounds - return; + return false; } } + const Character* const textBuffer = logicalModel->mText.Begin(); + startIndex = hitCharacter; endIndex = hitCharacter; - bool isHitCharacterWhitespace = TextAbstraction::IsWhiteSpace( logicalModel->mText[hitCharacter] ); - // Find the start and end of the text - for( startIndex = hitCharacter; startIndex > 0; --startIndex ) + // Whether the hit character is a new paragraph character. + const bool isHitCharacterNewParagraph = TextAbstraction::IsNewParagraph( *( textBuffer + hitCharacter ) ); + + // Whether the hit character is a white space. Note a new paragraph character is a white space as well but here is not wanted. + const bool isHitCharacterWhiteSpace = TextAbstraction::IsWhiteSpace( *( textBuffer + hitCharacter ) ) && !isHitCharacterNewParagraph; + + FindWordData data( textBuffer, + totalNumberOfCharacters, + hitCharacter, + isHitCharacterWhiteSpace, + isHitCharacterNewParagraph ); + + if( isHitCharacterNewParagraph ) { - if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( logicalModel->mText[ startIndex-1 ] ) ) + // Find the first character before the hit one which is not a new paragraph character. + + if( hitCharacter > 0 ) { - break; + endIndex = hitCharacter - 1u; + for( ; endIndex > 0; --endIndex ) + { + const Dali::Toolkit::Text::Character character = *( data.textBuffer + endIndex ); + + if( !Dali::TextAbstraction::IsNewParagraph( character ) ) + { + break; + } + } } + + data.hitCharacter = endIndex; + data.isNewParagraph = false; + data.isWhiteSpace = TextAbstraction::IsWhiteSpace( *( textBuffer + data.hitCharacter ) ); } - const CharacterIndex pastTheEnd = logicalModel->mText.Count(); - for( endIndex = hitCharacter + 1u; endIndex < pastTheEnd; ++endIndex ) + + // Find the start of the word. + FindStartOfWord( data ); + startIndex = data.foundIndex; + + // Find the end of the word. + FindEndOfWord( data ); + endIndex = data.foundIndex; + + if( 1u == ( endIndex - startIndex ) ) { - if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( logicalModel->mText[ endIndex ] ) ) + if( isHitCharacterWhiteSpace ) { - break; + // Select the word before or after the white space + + if( 0 == hitCharacter ) + { + data.isWhiteSpace = false; + FindEndOfWord( data ); + endIndex = data.foundIndex; + } + else if( hitCharacter > 0 ) + { + // Find the start of the word. + data.hitCharacter = hitCharacter - 1u; + data.isWhiteSpace = false; + FindStartOfWord( data ); + startIndex = data.foundIndex; + + --endIndex; + } } } + + return matchedCharacter; } } // namespace Text