mRightSelectionPosition( 0u ),
mPreEditStartPosition( 0u ),
mPreEditLength( 0u ),
+ mCursorHookPositionX( 0.f ),
mIsShowingPlaceholderText( false ),
mPreEditFlag( false ),
mDecoratorUpdated( false ),
mGrabHandleEnabled( true ),
mGrabHandlePopupEnabled( true ),
mSelectionEnabled( true ),
- mHorizontalScrollingEnabled( true ),
- mVerticalScrollingEnabled( false ),
mUpdateCursorPosition( false ),
+ mUpdateGrabHandlePosition( false ),
mUpdateLeftSelectionPosition( false ),
mUpdateRightSelectionPosition( false ),
+ mUpdateHighlightBox( false ),
mScrollAfterUpdatePosition( false ),
mScrollAfterDelete( false ),
mAllTextSelected( false ),
}
if( mEventData->mUpdateCursorPosition ||
- mEventData->mUpdateLeftSelectionPosition ||
- mEventData->mUpdateRightSelectionPosition )
+ mEventData->mUpdateHighlightBox )
{
NotifyImfManager();
}
{
// Updates the cursor position and scrolls the text to make it visible.
CursorInfo cursorInfo;
+ // Calculate the cursor position from the new cursor index.
GetCursorPosition( mEventData->mPrimaryCursorPosition,
cursorInfo );
+ if( mEventData->mUpdateCursorHookPosition )
+ {
+ // Update the cursor hook position. Used to move the cursor with the keys 'up' and 'down'.
+ mEventData->mCursorHookPositionX = cursorInfo.primaryPosition.x;
+ mEventData->mUpdateCursorHookPosition = false;
+ }
+
// Scroll first the text after delete ...
if( mEventData->mScrollAfterDelete )
{
// ... then, text can be scrolled to make the cursor visible.
if( mEventData->mScrollAfterUpdatePosition )
{
- ScrollToMakePositionVisible( cursorInfo.primaryPosition );
+ const Vector2 currentCursorPosition( cursorInfo.primaryPosition.x, cursorInfo.lineOffset );
+ ScrollToMakePositionVisible( currentCursorPosition, cursorInfo.lineHeight );
}
mEventData->mScrollAfterUpdatePosition = false;
mEventData->mScrollAfterDelete = false;
mEventData->mDecoratorUpdated = true;
mEventData->mUpdateCursorPosition = false;
+ mEventData->mUpdateGrabHandlePosition = false;
}
else
{
- bool leftScroll = false;
- bool rightScroll = false;
-
CursorInfo leftHandleInfo;
CursorInfo rightHandleInfo;
- if( mEventData->mUpdateLeftSelectionPosition )
+ if( mEventData->mUpdateHighlightBox )
{
GetCursorPosition( mEventData->mLeftSelectionPosition,
leftHandleInfo );
- if( mEventData->mScrollAfterUpdatePosition )
- {
- ScrollToMakePositionVisible( leftHandleInfo.primaryPosition );
- leftScroll = true;
- }
- }
-
- if( mEventData->mUpdateRightSelectionPosition )
- {
GetCursorPosition( mEventData->mRightSelectionPosition,
rightHandleInfo );
- if( mEventData->mScrollAfterUpdatePosition )
+ if( mEventData->mScrollAfterUpdatePosition && mEventData->mUpdateLeftSelectionPosition )
+ {
+ const Vector2 currentCursorPosition( leftHandleInfo.primaryPosition.x, leftHandleInfo.lineOffset );
+ ScrollToMakePositionVisible( currentCursorPosition, leftHandleInfo.lineHeight );
+ }
+
+ if( mEventData->mScrollAfterUpdatePosition && mEventData->mUpdateRightSelectionPosition )
{
- ScrollToMakePositionVisible( rightHandleInfo.primaryPosition );
- rightScroll = true;
+ const Vector2 currentCursorPosition( rightHandleInfo.primaryPosition.x, rightHandleInfo.lineOffset );
+ ScrollToMakePositionVisible( currentCursorPosition, rightHandleInfo.lineHeight );
}
}
SetPopupButtons();
mEventData->mDecoratorUpdated = true;
+ mEventData->mUpdateLeftSelectionPosition = false;
}
if( mEventData->mUpdateRightSelectionPosition )
SetPopupButtons();
mEventData->mDecoratorUpdated = true;
+ mEventData->mUpdateRightSelectionPosition = false;
}
- if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition )
+ if( mEventData->mUpdateHighlightBox )
{
RepositionSelectionHandles();
mEventData->mUpdateLeftSelectionPosition = false;
mEventData->mUpdateRightSelectionPosition = false;
+ mEventData->mUpdateHighlightBox = false;
}
- if( leftScroll || rightScroll )
- {
- mEventData->mScrollAfterUpdatePosition = false;
- }
+ mEventData->mScrollAfterUpdatePosition = false;
}
if( mEventData->mUpdateInputStyle )
}
else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
{
- // TODO
+ // Get first the line index of the current cursor position index.
+ CharacterIndex characterIndex = 0u;
+
+ if( mEventData->mPrimaryCursorPosition > 0u )
+ {
+ characterIndex = mEventData->mPrimaryCursorPosition - 1u;
+ }
+
+ const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( characterIndex );
+
+ if( lineIndex > 0u )
+ {
+ // Retrieve the cursor position info.
+ CursorInfo cursorInfo;
+ GetCursorPosition( mEventData->mPrimaryCursorPosition,
+ cursorInfo );
+
+ // Get the line above.
+ const LineRun& line = *( mVisualModel->mLines.Begin() + ( lineIndex - 1u ) );
+
+ // Get the next hit 'y' point.
+ const float hitPointY = cursorInfo.lineOffset - 0.5f * ( line.ascender - line.descender );
+
+ // Use the cursor hook position 'x' and the next hit 'y' position to calculate the new cursor index.
+ mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel,
+ mLogicalModel,
+ mMetrics,
+ mEventData->mCursorHookPositionX,
+ hitPointY );
+ }
}
else if( Dali::DALI_KEY_CURSOR_DOWN == keyCode )
{
- // TODO
+ // Get first the line index of the current cursor position index.
+ CharacterIndex characterIndex = 0u;
+
+ if( mEventData->mPrimaryCursorPosition > 0u )
+ {
+ characterIndex = mEventData->mPrimaryCursorPosition - 1u;
+ }
+
+ const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( characterIndex );
+
+ if( lineIndex + 1u < mVisualModel->mLines.Count() )
+ {
+ // Retrieve the cursor position info.
+ CursorInfo cursorInfo;
+ GetCursorPosition( mEventData->mPrimaryCursorPosition,
+ cursorInfo );
+
+ // Get the line below.
+ const LineRun& line = *( mVisualModel->mLines.Begin() + lineIndex + 1u );
+
+ // Get the next hit 'y' point.
+ const float hitPointY = cursorInfo.lineOffset + cursorInfo.lineHeight + 0.5f * ( line.ascender - line.descender );
+
+ // Use the cursor hook position 'x' and the next hit 'y' position to calculate the new cursor index.
+ mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel,
+ mLogicalModel,
+ mMetrics,
+ mEventData->mCursorHookPositionX,
+ hitPointY );
+ }
}
mEventData->mUpdateCursorPosition = true;
const float xPosition = event.p2.mFloat - mScrollPosition.x;
const float yPosition = event.p3.mFloat - mScrollPosition.y;
+ // Keep the tap 'x' position. Used to move the cursor.
+ mEventData->mCursorHookPositionX = xPosition;
+
mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel,
mLogicalModel,
mMetrics,
}
mEventData->mUpdateCursorPosition = true;
+ mEventData->mUpdateGrabHandlePosition = true;
mEventData->mScrollAfterUpdatePosition = true;
mEventData->mUpdateInputStyle = true;
if( ( Gesture::Started == state ) ||
( Gesture::Continuing == state ) )
{
- const Vector2& actualSize = mVisualModel->GetLayoutSize();
- const Vector2 currentScroll = mScrollPosition;
-
- if( mEventData->mHorizontalScrollingEnabled )
+ if( mEventData->mDecorator )
{
- const float displacementX = event.p2.mFloat;
- mScrollPosition.x += displacementX;
+ const Vector2& layoutSize = mVisualModel->GetLayoutSize();
+ const Vector2 currentScroll = mScrollPosition;
- ClampHorizontalScroll( actualSize );
- }
+ if( mEventData->mDecorator->IsHorizontalScrollEnabled() )
+ {
+ const float displacementX = event.p2.mFloat;
+ mScrollPosition.x += displacementX;
- if( mEventData->mVerticalScrollingEnabled )
- {
- const float displacementY = event.p3.mFloat;
- mScrollPosition.y += displacementY;
+ ClampHorizontalScroll( layoutSize );
+ }
- ClampVerticalScroll( actualSize );
- }
+ if( mEventData->mDecorator->IsVerticalScrollEnabled() )
+ {
+ const float displacementY = event.p3.mFloat;
+ mScrollPosition.y += displacementY;
+
+ ClampVerticalScroll( layoutSize );
+ }
- if( mEventData->mDecorator )
- {
mEventData->mDecorator->UpdatePositions( mScrollPosition - currentScroll );
}
}
const unsigned int state = event.p1.mUint;
const bool handleStopScrolling = ( HANDLE_STOP_SCROLLING == state );
+ const bool isSmoothHandlePanEnabled = mEventData->mDecorator->IsSmoothHandlePanEnabled();
if( HANDLE_PRESSED == state )
{
const float xPosition = event.p2.mFloat - mScrollPosition.x;
const float yPosition = event.p3.mFloat - mScrollPosition.y;
+ // Need to calculate the handle's new position.
const CharacterIndex handleNewPosition = Text::GetClosestCursorIndex( mVisualModel,
mLogicalModel,
mMetrics,
if( handleNewPosition != mEventData->mPrimaryCursorPosition )
{
- mEventData->mPrimaryCursorPosition = handleNewPosition;
+ // Updates the cursor position if the handle's new position is different than the current one.
mEventData->mUpdateCursorPosition = true;
+ // Does not update the grab handle position if the smooth panning is enabled. (The decorator does it smooth).
+ mEventData->mUpdateGrabHandlePosition = !isSmoothHandlePanEnabled;
+ mEventData->mPrimaryCursorPosition = handleNewPosition;
}
+
+ // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
+ mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
}
else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
{
if( ( handleNewPosition != mEventData->mLeftSelectionPosition ) &&
( handleNewPosition != mEventData->mRightSelectionPosition ) )
{
+ // Updates the highlight box if the handle's new position is different than the current one.
+ mEventData->mUpdateHighlightBox = true;
+ // Does not update the selection handle position if the smooth panning is enabled. (The decorator does it smooth).
+ mEventData->mUpdateLeftSelectionPosition = !isSmoothHandlePanEnabled;
mEventData->mLeftSelectionPosition = handleNewPosition;
-
- mEventData->mUpdateLeftSelectionPosition = true;
}
+
+ // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
+ mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
}
else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
{
if( ( handleNewPosition != mEventData->mRightSelectionPosition ) &&
( handleNewPosition != mEventData->mLeftSelectionPosition ) )
{
+ // Updates the highlight box if the handle's new position is different than the current one.
+ mEventData->mUpdateHighlightBox = true;
+ // Does not update the selection handle position if the smooth panning is enabled. (The decorator does it smooth).
+ mEventData->mUpdateRightSelectionPosition = !isSmoothHandlePanEnabled;
mEventData->mRightSelectionPosition = handleNewPosition;
-
- mEventData->mUpdateRightSelectionPosition = true;
}
+
+ // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
+ mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
}
} // end ( HANDLE_PRESSED == state )
else if( ( HANDLE_RELEASED == state ) ||
handleStopScrolling )
{
CharacterIndex handlePosition = 0u;
- if( handleStopScrolling )
+ if( handleStopScrolling || isSmoothHandlePanEnabled )
{
// Convert from decorator's coords to text's coords.
const float xPosition = event.p2.mFloat - mScrollPosition.x;
if( Event::GRAB_HANDLE_EVENT == event.type )
{
mEventData->mUpdateCursorPosition = true;
+ mEventData->mUpdateGrabHandlePosition = true;
mEventData->mUpdateInputStyle = true;
if( !IsClipboardEmpty() )
ChangeState( EventData::EDITING_WITH_PASTE_POPUP ); // Moving grabhandle will show Paste Popup
}
- if( handleStopScrolling )
+ if( handleStopScrolling || isSmoothHandlePanEnabled )
{
- mEventData->mScrollAfterUpdatePosition = mEventData->mPrimaryCursorPosition != handlePosition;
+ mEventData->mScrollAfterUpdatePosition = true;
mEventData->mPrimaryCursorPosition = handlePosition;
}
}
{
ChangeState( EventData::SELECTING );
- if( handleStopScrolling )
+ mEventData->mUpdateHighlightBox = true;
+ mEventData->mUpdateLeftSelectionPosition = true;
+
+ if( handleStopScrolling || isSmoothHandlePanEnabled )
{
- mEventData->mUpdateLeftSelectionPosition = ( mEventData->mRightSelectionPosition != handlePosition );
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateLeftSelectionPosition;
+ mEventData->mScrollAfterUpdatePosition = true;
- if( mEventData->mUpdateLeftSelectionPosition )
+ if( ( handlePosition != mEventData->mRightSelectionPosition ) &&
+ ( handlePosition != mEventData->mLeftSelectionPosition ) )
{
mEventData->mLeftSelectionPosition = handlePosition;
}
{
ChangeState( EventData::SELECTING );
- if( handleStopScrolling )
+ mEventData->mUpdateHighlightBox = true;
+ mEventData->mUpdateRightSelectionPosition = true;
+
+ if( handleStopScrolling || isSmoothHandlePanEnabled )
{
- mEventData->mUpdateRightSelectionPosition = ( mEventData->mLeftSelectionPosition != handlePosition );
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateRightSelectionPosition;
- if( mEventData->mUpdateRightSelectionPosition )
+ mEventData->mScrollAfterUpdatePosition = true;
+ if( ( handlePosition != mEventData->mRightSelectionPosition ) &&
+ ( handlePosition != mEventData->mLeftSelectionPosition ) )
{
mEventData->mRightSelectionPosition = handlePosition;
}
else if( HANDLE_SCROLLING == state )
{
const float xSpeed = event.p2.mFloat;
- const Vector2& actualSize = mVisualModel->GetLayoutSize();
+ const float ySpeed = event.p3.mFloat;
+ const Vector2& layoutSize = mVisualModel->GetLayoutSize();
const Vector2 currentScrollPosition = mScrollPosition;
mScrollPosition.x += xSpeed;
+ mScrollPosition.y += ySpeed;
- ClampHorizontalScroll( actualSize );
+ ClampHorizontalScroll( layoutSize );
+ ClampVerticalScroll( layoutSize );
bool endOfScroll = false;
if( Vector2::ZERO == ( currentScrollPosition - mScrollPosition ) )
// Set the position of the handle.
const bool scrollRightDirection = xSpeed > 0.f;
+ const bool scrollBottomDirection = ySpeed > 0.f;
const bool leftSelectionHandleEvent = Event::LEFT_SELECTION_HANDLE_EVENT == event.type;
const bool rightSelectionHandleEvent = Event::RIGHT_SELECTION_HANDLE_EVENT == event.type;
{
ChangeState( EventData::GRAB_HANDLE_PANNING );
+ // Get the grab handle position in decorator coords.
Vector2 position = mEventData->mDecorator->GetPosition( GRAB_HANDLE );
- // Position the grag handle close to either the left or right edge.
- position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width;
+ if( mEventData->mDecorator->IsHorizontalScrollEnabled() )
+ {
+ // Position the grag handle close to either the left or right edge.
+ position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width;
+ }
+
+ if( mEventData->mDecorator->IsVerticalScrollEnabled() )
+ {
+ position.x = mEventData->mCursorHookPositionX;
+
+ // Position the grag handle close to either the top or bottom edge.
+ position.y = scrollBottomDirection ? 0.f : mVisualModel->mControlSize.height;
+ }
// Get the new handle position.
// The grab handle's position is in decorator's coords. Need to transforms to text's coords.
position.x - mScrollPosition.x,
position.y - mScrollPosition.y );
- mEventData->mUpdateCursorPosition = mEventData->mPrimaryCursorPosition != handlePosition;
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateCursorPosition;
- mEventData->mPrimaryCursorPosition = handlePosition;
+ if( mEventData->mPrimaryCursorPosition != handlePosition )
+ {
+ mEventData->mUpdateCursorPosition = true;
+ mEventData->mUpdateGrabHandlePosition = !isSmoothHandlePanEnabled;
+ mEventData->mScrollAfterUpdatePosition = true;
+ mEventData->mPrimaryCursorPosition = handlePosition;
+ }
mEventData->mUpdateInputStyle = mEventData->mUpdateCursorPosition;
+
+ // Updates the decorator if the soft handle panning is enabled.
+ mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
}
else if( leftSelectionHandleEvent || rightSelectionHandleEvent )
{
- // TODO: This is recalculating the selection box every time the text is scrolled with the selection handles.
- // Think if something can be done to save power.
-
ChangeState( EventData::SELECTION_HANDLE_PANNING );
+ // Get the selection handle position in decorator coords.
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 : mVisualModel->mControlSize.width;
+ if( mEventData->mDecorator->IsHorizontalScrollEnabled() )
+ {
+ // Position the selection handle close to either the left or right edge.
+ position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width;
+ }
+
+ if( mEventData->mDecorator->IsVerticalScrollEnabled() )
+ {
+ position.x = mEventData->mCursorHookPositionX;
+
+ // Position the grag handle close to either the top or bottom edge.
+ position.y = scrollBottomDirection ? 0.f : mVisualModel->mControlSize.height;
+ }
// Get the new handle position.
// The selection handle's position is in decorator's coords. Need to transform to text's coords.
if( leftSelectionHandleEvent )
{
const bool differentHandles = ( mEventData->mLeftSelectionPosition != handlePosition ) && ( mEventData->mRightSelectionPosition != handlePosition );
- mEventData->mUpdateLeftSelectionPosition = endOfScroll || differentHandles;
- if( differentHandles )
+
+ if( differentHandles || endOfScroll )
{
+ mEventData->mUpdateHighlightBox = true;
+ mEventData->mUpdateLeftSelectionPosition = !isSmoothHandlePanEnabled;
+ mEventData->mUpdateRightSelectionPosition = isSmoothHandlePanEnabled;
mEventData->mLeftSelectionPosition = handlePosition;
}
}
else
{
const bool differentHandles = ( mEventData->mRightSelectionPosition != handlePosition ) && ( mEventData->mLeftSelectionPosition != handlePosition );
- mEventData->mUpdateRightSelectionPosition = endOfScroll || differentHandles;
- if( differentHandles )
+ if( differentHandles || endOfScroll )
{
+ mEventData->mUpdateHighlightBox = true;
+ mEventData->mUpdateRightSelectionPosition = !isSmoothHandlePanEnabled;
+ mEventData->mUpdateLeftSelectionPosition = isSmoothHandlePanEnabled;
mEventData->mRightSelectionPosition = handlePosition;
}
}
{
RepositionSelectionHandles();
- mEventData->mScrollAfterUpdatePosition = true;
+ mEventData->mScrollAfterUpdatePosition = !isSmoothHandlePanEnabled;
}
}
mEventData->mDecoratorUpdated = true;
// Calculates the logical position from the x,y coords.
RepositionSelectionHandles( xPosition,
yPosition );
-
- mEventData->mUpdateLeftSelectionPosition = true;
- mEventData->mUpdateRightSelectionPosition = true;
- mEventData->mUpdateCursorPosition = false;
-
- mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
}
}
if( mEventData->mSelectionEnabled )
{
+ ChangeState( EventData::SELECTING );
+
mEventData->mLeftSelectionPosition = 0u;
mEventData->mRightSelectionPosition = mLogicalModel->mText.Count();
mEventData->mScrollAfterUpdatePosition = true;
mEventData->mUpdateLeftSelectionPosition = true;
mEventData->mUpdateRightSelectionPosition = true;
+ mEventData->mUpdateHighlightBox = true;
}
}
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.
-
const bool isLastCharacter = selectionEnd >= mLogicalModel->mText.Count();
const CharacterDirection startDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + selectionStart ) );
const CharacterDirection endDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + ( selectionEnd - ( isLastCharacter ? 1u : 0u ) ) ) );
selectionBoxInfo->minX = MAX_FLOAT;
selectionBoxInfo->maxX = MIN_FLOAT;
+ // Keep the min and max 'x' position to calculate the size and position of the highlighed text.
+ float minHighlightX = std::numeric_limits<float>::max();
+ float maxHighlightX = std::numeric_limits<float>::min();
+ Size highLightSize;
+ Vector2 highLightPosition; // The highlight position in decorator's coords.
+
// Retrieve the first line and get the line's vertical offset, the line's height and the index to the last glyph.
// The line's vertical offset of all the lines before the line where the first glyph is laid-out.
selectionBoxInfo->lineOffset = CalculateLineOffset( mVisualModel->mLines,
firstLineIndex );
+
+ // Transform to decorator's (control) coords.
+ selectionBoxInfo->lineOffset += mScrollPosition.y;
+
lineRun += firstLineIndex;
// The line height is the addition of the line ascender and the line descender.
const float xPosition = lineRun->alignmentOffset + position.x - glyph.xBearing + mScrollPosition.x + glyphAdvance * static_cast<float>( isCurrentRightToLeft ? ( numberOfCharactersStart - interGlyphIndex - numberOfCharacters ) : interGlyphIndex );
const float xPositionAdvance = xPosition + static_cast<float>( numberOfCharacters ) * glyphAdvance;
- const float yPosition = selectionBoxInfo->lineOffset + mScrollPosition.y;
+ const float yPosition = selectionBoxInfo->lineOffset;
// Store the min and max 'x' for each line.
selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
const float xPosition = lineRun->alignmentOffset + position.x - glyph.xBearing + mScrollPosition.x + ( isCurrentRightToLeft ? ( glyphAdvance * static_cast<float>( numberOfCharacters ) ) : 0.f );
const float xPositionAdvance = xPosition + static_cast<float>( interGlyphIndex ) * glyphAdvance;
- const float yPosition = selectionBoxInfo->lineOffset + mScrollPosition.y;
+ const float yPosition = selectionBoxInfo->lineOffset;
// Store the min and max 'x' for each line.
selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
const float xPosition = lineRun->alignmentOffset + position.x - glyph.xBearing + mScrollPosition.x;
const float xPositionAdvance = xPosition + glyph.advance;
- const float yPosition = selectionBoxInfo->lineOffset + mScrollPosition.y;
+ const float yPosition = selectionBoxInfo->lineOffset;
// Store the min and max 'x' for each line.
selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
++lineIndex;
if( lineIndex < firstLineIndex + numberOfLines )
{
- // Get the selection box info for the next line.
+ // Keep the offset and height of the current selection box.
const float currentLineOffset = selectionBoxInfo->lineOffset;
+ const float currentLineHeight = selectionBoxInfo->lineHeight;
+
+ // Get the selection box info for the next line.
++selectionBoxInfo;
selectionBoxInfo->minX = MAX_FLOAT;
selectionBoxInfo->maxX = MIN_FLOAT;
+ // Update the line's vertical offset.
+ selectionBoxInfo->lineOffset = currentLineOffset + currentLineHeight;
+
// The line height is the addition of the line ascender and the line descender.
// However, the line descender has a negative value, hence the subtraction.
selectionBoxInfo->lineHeight = lineRun->ascender - lineRun->descender;
-
- // Update the line's vertical offset.
- selectionBoxInfo->lineOffset = currentLineOffset + selectionBoxInfo->lineHeight;
}
}
}
+ // Traverses all the lines and updates the min and max 'x' positions and the total height.
+ // The final width is calculated after 'boxifying' the selection.
+ for( Vector<SelectionBoxInfo>::ConstIterator it = selectionBoxLinesInfo.Begin(),
+ endIt = selectionBoxLinesInfo.End();
+ it != endIt;
+ ++it )
+ {
+ const SelectionBoxInfo& info = *it;
+
+ // Update the size of the highlighted text.
+ highLightSize.height += selectionBoxInfo->lineHeight;
+ minHighlightX = std::min( minHighlightX, info.minX );
+ maxHighlightX = std::max( maxHighlightX, info.maxX );
+ }
+
// Add extra geometry to 'boxify' the selection.
if( 1u < numberOfLines )
firstSelectionBoxLineInfo.lineOffset,
firstSelectionBoxLineInfo.minX,
firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight );
+
+ // Update the size of the highlighted text.
+ minHighlightX = 0.f;
}
if( boxifyEnd )
firstSelectionBoxLineInfo.lineOffset,
mVisualModel->mControlSize.width,
firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight );
+
+ // Update the size of the highlighted text.
+ maxHighlightX = mVisualModel->mControlSize.width;
}
// Boxify the central lines.
mVisualModel->mControlSize.width,
info.lineOffset + info.lineHeight );
}
+
+ // Update the size of the highlighted text.
+ minHighlightX = 0.f;
+ maxHighlightX = mVisualModel->mControlSize.width;
}
// Boxify the last line.
lastSelectionBoxLineInfo.lineOffset,
lastSelectionBoxLineInfo.minX,
lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight );
+
+ // Update the size of the highlighted text.
+ minHighlightX = 0.f;
}
if( boxifyEnd )
lastSelectionBoxLineInfo.lineOffset,
mVisualModel->mControlSize.width,
lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight );
+
+ // Update the size of the highlighted text.
+ maxHighlightX = mVisualModel->mControlSize.width;
}
}
+ // Sets the highlight's size and position. In decorator's coords.
+ // The highlight's height has been calculated above (before 'boxifying' the highlight).
+ highLightSize.width = maxHighlightX - minHighlightX;
+
+ highLightPosition.x = minHighlightX;
+ const SelectionBoxInfo& firstSelectionBoxLineInfo = *( selectionBoxLinesInfo.Begin() );
+ highLightPosition.y = firstSelectionBoxLineInfo.lineOffset;
+
+ mEventData->mDecorator->SetHighLightBox( highLightPosition, highLightSize );
+
+ if( !mEventData->mDecorator->IsSmoothHandlePanEnabled() )
+ {
+ CursorInfo primaryCursorInfo;
+ GetCursorPosition( mEventData->mLeftSelectionPosition,
+ primaryCursorInfo );
- CursorInfo primaryCursorInfo;
- GetCursorPosition( mEventData->mLeftSelectionPosition,
- primaryCursorInfo );
+ const Vector2 primaryPosition = primaryCursorInfo.primaryPosition + mScrollPosition;
- CursorInfo secondaryCursorInfo;
- GetCursorPosition( mEventData->mRightSelectionPosition,
- secondaryCursorInfo );
+ mEventData->mDecorator->SetPosition( LEFT_SELECTION_HANDLE,
+ primaryPosition.x,
+ primaryCursorInfo.lineOffset + mScrollPosition.y,
+ primaryCursorInfo.lineHeight );
- const Vector2 primaryPosition = primaryCursorInfo.primaryPosition + mScrollPosition;
- const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + mScrollPosition;
+ CursorInfo secondaryCursorInfo;
+ GetCursorPosition( mEventData->mRightSelectionPosition,
+ secondaryCursorInfo );
- mEventData->mDecorator->SetPosition( LEFT_SELECTION_HANDLE,
- primaryPosition.x,
- primaryCursorInfo.lineOffset + mScrollPosition.y,
- primaryCursorInfo.lineHeight );
+ const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + mScrollPosition;
- mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE,
- secondaryPosition.x,
- secondaryCursorInfo.lineOffset + mScrollPosition.y,
- secondaryCursorInfo.lineHeight );
+ mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE,
+ secondaryPosition.x,
+ secondaryCursorInfo.lineOffset + mScrollPosition.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;
// Find which word was selected
CharacterIndex selectionStart( 0 );
CharacterIndex selectionEnd( 0 );
- FindSelectionIndices( mVisualModel,
- mLogicalModel,
- mMetrics,
- visualX,
- visualY,
- selectionStart,
- selectionEnd );
+ const bool indicesFound = 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 )
+ if( indicesFound )
{
- ChangeState( EventData::EDITING );
- // Nothing to select. i.e. a white space, out of bounds
- return;
+ ChangeState( EventData::SELECTING );
+
+ mEventData->mLeftSelectionPosition = selectionStart;
+ mEventData->mRightSelectionPosition = selectionEnd;
+
+ mEventData->mUpdateLeftSelectionPosition = true;
+ mEventData->mUpdateRightSelectionPosition = true;
+ mEventData->mUpdateHighlightBox = true;
+
+ mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
}
+ else
+ {
+ // Nothing to select. i.e. a white space, out of bounds
+ ChangeState( EventData::EDITING );
+
+ mEventData->mPrimaryCursorPosition = selectionEnd;
- mEventData->mLeftSelectionPosition = selectionStart;
- mEventData->mRightSelectionPosition = selectionEnd;
+ mEventData->mUpdateCursorPosition = true;
+ mEventData->mUpdateGrabHandlePosition = true;
+ mEventData->mScrollAfterUpdatePosition = true;
+ mEventData->mUpdateInputStyle = true;
+ }
}
void Controller::Impl::SetPopupButtons()
cursorIndex += numberOfCharacters;
}
+ // Will update the cursor hook position.
+ mEventData->mUpdateCursorHookPosition = true;
+
return cursorIndex;
}
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,
- cursorInfo.lineOffset + mScrollPosition.y,
- cursorInfo.lineHeight );
+ if( mEventData->mUpdateGrabHandlePosition )
+ {
+ // Sets the grab handle position.
+ mEventData->mDecorator->SetPosition( GRAB_HANDLE,
+ cursorPosition.x,
+ cursorInfo.lineOffset + mScrollPosition.y,
+ cursorInfo.lineHeight );
+ }
if( cursorInfo.isSecondaryCursor )
{
}
}
-void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position )
+void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position, float lineHeight )
{
- const float cursorWidth = mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f;
+ const float cursorWidth = mEventData->mDecorator ? static_cast<float>( mEventData->mDecorator->GetCursorWidth() ) : 0.f;
// position is in actor's coords.
- const float positionEnd = position.x + cursorWidth;
+ const float positionEndX = position.x + cursorWidth;
+ const float positionEndY = position.y + lineHeight;
// Transform the position to decorator coords.
- const float decoratorPositionBegin = position.x + mScrollPosition.x;
- const float decoratorPositionEnd = positionEnd + mScrollPosition.x;
+ const float decoratorPositionBeginX = position.x + mScrollPosition.x;
+ const float decoratorPositionEndX = positionEndX + mScrollPosition.x;
- if( decoratorPositionBegin < 0.f )
+ const float decoratorPositionBeginY = position.y + mScrollPosition.y;
+ const float decoratorPositionEndY = positionEndY + mScrollPosition.y;
+
+ if( decoratorPositionBeginX < 0.f )
{
mScrollPosition.x = -position.x;
}
- else if( decoratorPositionEnd > mVisualModel->mControlSize.width )
+ else if( decoratorPositionEndX > mVisualModel->mControlSize.width )
+ {
+ mScrollPosition.x = mVisualModel->mControlSize.width - positionEndX;
+ }
+
+ if( decoratorPositionBeginY < 0.f )
+ {
+ mScrollPosition.y = -position.y;
+ }
+ else if( decoratorPositionEndY > mVisualModel->mControlSize.height )
{
- mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd;
+ mScrollPosition.y = mVisualModel->mControlSize.height - positionEndY;
}
}
// Calculate the offset to match the cursor position before the character was deleted.
mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x;
+ mScrollPosition.y = currentCursorPosition.y - cursorInfo.lineOffset;
ClampHorizontalScroll( mVisualModel->GetLayoutSize() );
+ ClampVerticalScroll( mVisualModel->GetLayoutSize() );
// Makes the new cursor position visible if needed.
- ScrollToMakePositionVisible( cursorInfo.primaryPosition );
+ ScrollToMakePositionVisible( cursorInfo.primaryPosition, cursorInfo.lineHeight );
}
void Controller::Impl::RequestRelayout()