Text - Replace the if/else in the ChangeState method by a switch/case.

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller-impl.cpp
diff --git a/dali-toolkit/internal/text/text-controller-impl.cpp b/dali-toolkit/internal/text/text-controller-impl.cpp

index 95266cd..6cf26fc 100644 (file)
--- a/dali-toolkit/internal/text/text-controller-impl.cpp
+++ b/dali-toolkit/internal/text/text-controller-impl.cpp
@@ -21,12 +21,13 @@
  // EXTERNAL INCLUDES
  #include <dali/public-api/adaptor-framework/key.h>
  #include <dali/integration-api/debug.h>
  // EXTERNAL INCLUDES
  #include <dali/public-api/adaptor-framework/key.h>
  #include <dali/integration-api/debug.h>
+#include <limits>
  
  // INTERNAL INCLUDES
  #include <dali-toolkit/internal/text/bidirectional-support.h>
  #include <dali-toolkit/internal/text/character-set-conversion.h>
  #include <dali-toolkit/internal/text/color-segmentation.h>
  
  // INTERNAL INCLUDES
  #include <dali-toolkit/internal/text/bidirectional-support.h>
  #include <dali-toolkit/internal/text/character-set-conversion.h>
  #include <dali-toolkit/internal/text/color-segmentation.h>
-#include <dali-toolkit/internal/text/glyph-metrics-helper.h>
+#include <dali-toolkit/internal/text/cursor-helper-functions.h>
  #include <dali-toolkit/internal/text/multi-language-support.h>
  #include <dali-toolkit/internal/text/segmentation.h>
  #include <dali-toolkit/internal/text/shaper.h>
  #include <dali-toolkit/internal/text/multi-language-support.h>
  #include <dali-toolkit/internal/text/segmentation.h>
  #include <dali-toolkit/internal/text/shaper.h>
@@ -35,10 +36,25 @@
  namespace
  {
  
  namespace
  {
  
+/**
+ * @brief Struct used to calculate the selection box.
+ */
+struct SelectionBoxInfo
+{
+  float lineOffset;
+  float lineHeight;
+  float minX;
+  float maxX;
+};
+
  #if defined(DEBUG_ENABLED)
    Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
  #endif
  
  #if defined(DEBUG_ENABLED)
    Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
  #endif
  
+const float MAX_FLOAT = std::numeric_limits<float>::max();
+const float MIN_FLOAT = std::numeric_limits<float>::min();
+const Dali::Toolkit::Text::CharacterDirection LTR = false; ///< Left To Right direction
+
  } // namespace
  
  namespace Dali
  } // namespace
  
  namespace Dali
@@ -57,13 +73,13 @@ EventData::EventData( DecoratorPtr decorator )
    mPlaceholderTextInactive(),
    mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ),
    mEventQueue(),
    mPlaceholderTextInactive(),
    mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ),
    mEventQueue(),
-  mScrollPosition(),
    mState( INACTIVE ),
    mPrimaryCursorPosition( 0u ),
    mLeftSelectionPosition( 0u ),
    mRightSelectionPosition( 0u ),
    mPreEditStartPosition( 0u ),
    mPreEditLength( 0u ),
    mState( INACTIVE ),
    mPrimaryCursorPosition( 0u ),
    mLeftSelectionPosition( 0u ),
    mRightSelectionPosition( 0u ),
    mPreEditStartPosition( 0u ),
    mPreEditLength( 0u ),
+  mCursorHookPositionX( 0.f ),
    mIsShowingPlaceholderText( false ),
    mPreEditFlag( false ),
    mDecoratorUpdated( false ),
    mIsShowingPlaceholderText( false ),
    mPreEditFlag( false ),
    mDecoratorUpdated( false ),
@@ -71,11 +87,11 @@ EventData::EventData( DecoratorPtr decorator )
    mGrabHandleEnabled( true ),
    mGrabHandlePopupEnabled( true ),
    mSelectionEnabled( true ),
    mGrabHandleEnabled( true ),
    mGrabHandlePopupEnabled( true ),
    mSelectionEnabled( true ),
-  mHorizontalScrollingEnabled( true ),
-  mVerticalScrollingEnabled( false ),
    mUpdateCursorPosition( false ),
    mUpdateCursorPosition( false ),
+  mUpdateGrabHandlePosition( false ),
    mUpdateLeftSelectionPosition( false ),
    mUpdateRightSelectionPosition( false ),
    mUpdateLeftSelectionPosition( false ),
    mUpdateRightSelectionPosition( false ),
+  mUpdateHighlightBox( false ),
    mScrollAfterUpdatePosition( false ),
    mScrollAfterDelete( false ),
    mAllTextSelected( false ),
    mScrollAfterUpdatePosition( false ),
    mScrollAfterDelete( false ),
    mAllTextSelected( false ),
@@ -146,59 +162,72 @@ bool Controller::Impl::ProcessInputEvents()
      }
    }
  
      }
    }
  
+  if( mEventData->mUpdateCursorPosition ||
+      mEventData->mUpdateHighlightBox )
+  {
+    NotifyImfManager();
+  }
+
    // The cursor must also be repositioned after inserts into the model
    if( mEventData->mUpdateCursorPosition )
    {
      // Updates the cursor position and scrolls the text to make it visible.
      CursorInfo cursorInfo;
    // The cursor must also be repositioned after inserts into the model
    if( mEventData->mUpdateCursorPosition )
    {
      // 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 );
  
      GetCursorPosition( mEventData->mPrimaryCursorPosition,
                         cursorInfo );
  
-    if( mEventData->mScrollAfterUpdatePosition )
+    if( mEventData->mUpdateCursorHookPosition )
      {
      {
-      ScrollToMakePositionVisible( cursorInfo.primaryPosition );
-      mEventData->mScrollAfterUpdatePosition = false;
+      // Update the cursor hook position. Used to move the cursor with the keys 'up' and 'down'.
+      mEventData->mCursorHookPositionX = cursorInfo.primaryPosition.x;
+      mEventData->mUpdateCursorHookPosition = false;
      }
      }
-    else if( mEventData->mScrollAfterDelete )
+
+    // Scroll first the text after delete ...
+    if( mEventData->mScrollAfterDelete )
      {
        ScrollTextToMatchCursor( cursorInfo );
      {
        ScrollTextToMatchCursor( cursorInfo );
-      mEventData->mScrollAfterDelete = false;
      }
  
      }
  
+    // ... then, text can be scrolled to make the cursor visible.
+    if( mEventData->mScrollAfterUpdatePosition )
+    {
+      const Vector2 currentCursorPosition( cursorInfo.primaryPosition.x, cursorInfo.lineOffset );
+      ScrollToMakePositionVisible( currentCursorPosition, cursorInfo.lineHeight );
+    }
+    mEventData->mScrollAfterUpdatePosition = false;
+    mEventData->mScrollAfterDelete = false;
+
      UpdateCursorPosition( cursorInfo );
  
      mEventData->mDecoratorUpdated = true;
      mEventData->mUpdateCursorPosition = false;
      UpdateCursorPosition( cursorInfo );
  
      mEventData->mDecoratorUpdated = true;
      mEventData->mUpdateCursorPosition = false;
+    mEventData->mUpdateGrabHandlePosition = false;
    }
    else
    {
    }
    else
    {
-    bool leftScroll = false;
-    bool rightScroll = false;
-
      CursorInfo leftHandleInfo;
      CursorInfo rightHandleInfo;
  
      CursorInfo leftHandleInfo;
      CursorInfo rightHandleInfo;
  
-    if( mEventData->mUpdateLeftSelectionPosition )
+    if( mEventData->mUpdateHighlightBox )
      {
        GetCursorPosition( mEventData->mLeftSelectionPosition,
                           leftHandleInfo );
  
      {
        GetCursorPosition( mEventData->mLeftSelectionPosition,
                           leftHandleInfo );
  
-      if( mEventData->mScrollAfterUpdatePosition )
-      {
-        ScrollToMakePositionVisible( leftHandleInfo.primaryPosition );
-        leftScroll = true;
-      }
-    }
-
-    if( mEventData->mUpdateRightSelectionPosition )
-    {
        GetCursorPosition( mEventData->mRightSelectionPosition,
                           rightHandleInfo );
  
        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 );
        }
      }
  
        }
      }
  
@@ -209,6 +238,7 @@ bool Controller::Impl::ProcessInputEvents()
  
        SetPopupButtons();
        mEventData->mDecoratorUpdated = true;
  
        SetPopupButtons();
        mEventData->mDecoratorUpdated = true;
+      mEventData->mUpdateLeftSelectionPosition = false;
      }
  
      if( mEventData->mUpdateRightSelectionPosition )
      }
  
      if( mEventData->mUpdateRightSelectionPosition )
@@ -218,20 +248,19 @@ bool Controller::Impl::ProcessInputEvents()
  
        SetPopupButtons();
        mEventData->mDecoratorUpdated = true;
  
        SetPopupButtons();
        mEventData->mDecoratorUpdated = true;
+      mEventData->mUpdateRightSelectionPosition = false;
      }
  
      }
  
-    if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition )
+    if( mEventData->mUpdateHighlightBox )
      {
        RepositionSelectionHandles();
  
        mEventData->mUpdateLeftSelectionPosition = false;
        mEventData->mUpdateRightSelectionPosition = false;
      {
        RepositionSelectionHandles();
  
        mEventData->mUpdateLeftSelectionPosition = false;
        mEventData->mUpdateRightSelectionPosition = false;
+      mEventData->mUpdateHighlightBox = false;
      }
  
      }
  
-    if( leftScroll || rightScroll )
-    {
-      mEventData->mScrollAfterUpdatePosition = false;
-    }
+    mEventData->mScrollAfterUpdatePosition = false;
    }
  
    if( mEventData->mUpdateInputStyle )
    }
  
    if( mEventData->mUpdateInputStyle )
@@ -258,6 +287,80 @@ bool Controller::Impl::ProcessInputEvents()
    return decoratorUpdated;
  }
  
    return decoratorUpdated;
  }
  
+void Controller::Impl::NotifyImfManager()
+{
+  if( mEventData && mEventData->mImfManager )
+  {
+    CharacterIndex cursorPosition = GetLogicalCursorPosition();
+
+    const Length numberOfWhiteSpaces = GetNumberOfWhiteSpaces( 0u );
+
+    // Update the cursor position by removing the initial white spaces.
+    if( cursorPosition < numberOfWhiteSpaces )
+    {
+      cursorPosition = 0u;
+    }
+    else
+    {
+      cursorPosition -= numberOfWhiteSpaces;
+    }
+
+    mEventData->mImfManager.SetCursorPosition( cursorPosition );
+    mEventData->mImfManager.NotifyCursorPosition();
+  }
+}
+
+CharacterIndex Controller::Impl::GetLogicalCursorPosition() const
+{
+  CharacterIndex cursorPosition = 0u;
+
+  if( mEventData )
+  {
+    if( ( EventData::SELECTING == mEventData->mState ) ||
+        ( EventData::SELECTION_HANDLE_PANNING == mEventData->mState ) )
+    {
+      cursorPosition = std::min( mEventData->mRightSelectionPosition, mEventData->mLeftSelectionPosition );
+    }
+    else
+    {
+      cursorPosition = mEventData->mPrimaryCursorPosition;
+    }
+  }
+
+  return cursorPosition;
+}
+
+Length Controller::Impl::GetNumberOfWhiteSpaces( CharacterIndex index ) const
+{
+  Length numberOfWhiteSpaces = 0u;
+
+  // Get the buffer to the text.
+  Character* utf32CharacterBuffer = mLogicalModel->mText.Begin();
+
+  const Length totalNumberOfCharacters = mLogicalModel->mText.Count();
+  for( ; index < totalNumberOfCharacters; ++index, ++numberOfWhiteSpaces )
+  {
+    if( !TextAbstraction::IsWhiteSpace( *( utf32CharacterBuffer + index ) ) )
+    {
+      break;
+    }
+  }
+
+  return numberOfWhiteSpaces;
+}
+
+void Controller::Impl::GetText( CharacterIndex index, std::string& text ) const
+{
+  // Get the total number of characters.
+  Length numberOfCharacters = mLogicalModel->mText.Count();
+
+  // Retrieve the text.
+  if( 0u != numberOfCharacters )
+  {
+    Utf32ToUtf8( mLogicalModel->mText.Begin() + index, numberOfCharacters - index, text );
+  }
+}
+
  void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
  {
    mTextUpdateInfo.mParagraphCharacterIndex = 0u;
  void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
  {
    mTextUpdateInfo.mParagraphCharacterIndex = 0u;
@@ -300,17 +403,17 @@ void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
    }
    else
    {
    }
    else
    {
-    CharacterIndex lastIndex = 0u;
+    Length numberOfCharactersToUpdate = 0u;
      if( mTextUpdateInfo.mFullRelayoutNeeded )
      {
      if( mTextUpdateInfo.mFullRelayoutNeeded )
      {
-      lastIndex = mTextUpdateInfo.mPreviousNumberOfCharacters;
+      numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters;
      }
      else
      {
      }
      else
      {
-      lastIndex = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
+      numberOfCharactersToUpdate = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
      }
      mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex,
      }
      mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex,
-                                   lastIndex,
+                                   numberOfCharactersToUpdate,
                                     paragraphsToBeUpdated );
    }
  
                                     paragraphsToBeUpdated );
    }
  
@@ -345,36 +448,36 @@ void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
  
  void Controller::Impl::ClearFullModelData( OperationsMask operations )
  {
  
  void Controller::Impl::ClearFullModelData( OperationsMask operations )
  {
-  if( GET_LINE_BREAKS & operations )
+  if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
    {
      mLogicalModel->mLineBreakInfo.Clear();
      mLogicalModel->mParagraphInfo.Clear();
    }
  
    {
      mLogicalModel->mLineBreakInfo.Clear();
      mLogicalModel->mParagraphInfo.Clear();
    }
  
-  if( GET_WORD_BREAKS & operations )
+  if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
    {
      mLogicalModel->mLineBreakInfo.Clear();
    }
  
    {
      mLogicalModel->mLineBreakInfo.Clear();
    }
  
-  if( GET_SCRIPTS & operations )
+  if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
    {
      mLogicalModel->mScriptRuns.Clear();
    }
  
    {
      mLogicalModel->mScriptRuns.Clear();
    }
  
-  if( VALIDATE_FONTS & operations )
+  if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
    {
      mLogicalModel->mFontRuns.Clear();
    }
  
    if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
    {
    {
      mLogicalModel->mFontRuns.Clear();
    }
  
    if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
    {
-    if( BIDI_INFO & operations )
+    if( NO_OPERATION != ( BIDI_INFO & operations ) )
      {
        mLogicalModel->mBidirectionalParagraphInfo.Clear();
        mLogicalModel->mCharacterDirections.Clear();
      }
  
      {
        mLogicalModel->mBidirectionalParagraphInfo.Clear();
        mLogicalModel->mCharacterDirections.Clear();
      }
  
-    if( REORDER & operations )
+    if( NO_OPERATION != ( REORDER & operations ) )
      {
        // Free the allocated memory used to store the conversion table in the bidirectional line info run.
        for( Vector<BidirectionalLineInfoRun>::Iterator it = mLogicalModel->mBidirectionalLineInfo.Begin(),
      {
        // Free the allocated memory used to store the conversion table in the bidirectional line info run.
        for( Vector<BidirectionalLineInfoRun>::Iterator it = mLogicalModel->mBidirectionalLineInfo.Begin(),
@@ -388,13 +491,10 @@ void Controller::Impl::ClearFullModelData( OperationsMask operations )
          bidiLineInfo.visualToLogicalMap = NULL;
        }
        mLogicalModel->mBidirectionalLineInfo.Clear();
          bidiLineInfo.visualToLogicalMap = NULL;
        }
        mLogicalModel->mBidirectionalLineInfo.Clear();
-
-      mLogicalModel->mLogicalToVisualMap.Clear();
-      mLogicalModel->mVisualToLogicalMap.Clear();
      }
    }
  
      }
    }
  
-  if( SHAPE_TEXT & operations )
+  if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
    {
      mVisualModel->mGlyphs.Clear();
      mVisualModel->mGlyphsToCharacters.Clear();
    {
      mVisualModel->mGlyphs.Clear();
      mVisualModel->mGlyphsToCharacters.Clear();
@@ -404,12 +504,12 @@ void Controller::Impl::ClearFullModelData( OperationsMask operations )
      mVisualModel->mGlyphPositions.Clear();
    }
  
      mVisualModel->mGlyphPositions.Clear();
    }
  
-  if( LAYOUT & operations )
+  if( NO_OPERATION != ( LAYOUT & operations ) )
    {
      mVisualModel->mLines.Clear();
    }
  
    {
      mVisualModel->mLines.Clear();
    }
  
-  if( COLOR & operations )
+  if( NO_OPERATION != ( COLOR & operations ) )
    {
      mVisualModel->mColorIndices.Clear();
    }
    {
      mVisualModel->mColorIndices.Clear();
    }
@@ -419,7 +519,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
  {
    const CharacterIndex endIndexPlusOne = endIndex + 1u;
  
  {
    const CharacterIndex endIndexPlusOne = endIndex + 1u;
  
-  if( GET_LINE_BREAKS & operations )
+  if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
    {
      // Clear the line break info.
      LineBreakInfo* lineBreakInfoBuffer = mLogicalModel->mLineBreakInfo.Begin();
    {
      // Clear the line break info.
      LineBreakInfo* lineBreakInfoBuffer = mLogicalModel->mLineBreakInfo.Begin();
@@ -433,7 +533,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
                          mLogicalModel->mParagraphInfo );
    }
  
                          mLogicalModel->mParagraphInfo );
    }
  
-  if( GET_WORD_BREAKS & operations )
+  if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
    {
      // Clear the word break info.
      WordBreakInfo* wordBreakInfoBuffer = mLogicalModel->mWordBreakInfo.Begin();
    {
      // Clear the word break info.
      WordBreakInfo* wordBreakInfoBuffer = mLogicalModel->mWordBreakInfo.Begin();
@@ -442,7 +542,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
                                           wordBreakInfoBuffer + endIndexPlusOne );
    }
  
                                           wordBreakInfoBuffer + endIndexPlusOne );
    }
  
-  if( GET_SCRIPTS & operations )
+  if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
    {
      // Clear the scripts.
      ClearCharacterRuns( startIndex,
    {
      // Clear the scripts.
      ClearCharacterRuns( startIndex,
@@ -450,7 +550,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
                          mLogicalModel->mScriptRuns );
    }
  
                          mLogicalModel->mScriptRuns );
    }
  
-  if( VALIDATE_FONTS & operations )
+  if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
    {
      // Clear the fonts.
      ClearCharacterRuns( startIndex,
    {
      // Clear the fonts.
      ClearCharacterRuns( startIndex,
@@ -460,7 +560,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
  
    if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
    {
  
    if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
    {
-    if( BIDI_INFO & operations )
+    if( NO_OPERATION != ( BIDI_INFO & operations ) )
      {
        // Clear the bidirectional paragraph info.
        ClearCharacterRuns( startIndex,
      {
        // Clear the bidirectional paragraph info.
        ClearCharacterRuns( startIndex,
@@ -474,7 +574,7 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
                                                   characterDirectionsBuffer + endIndexPlusOne );
      }
  
                                                   characterDirectionsBuffer + endIndexPlusOne );
      }
  
-    if( REORDER & operations )
+    if( NO_OPERATION != ( REORDER & operations ) )
      {
        uint32_t startRemoveIndex = mLogicalModel->mBidirectionalLineInfo.Count();
        uint32_t endRemoveIndex = startRemoveIndex;
      {
        uint32_t startRemoveIndex = mLogicalModel->mBidirectionalLineInfo.Count();
        uint32_t endRemoveIndex = startRemoveIndex;
@@ -500,15 +600,6 @@ void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, Chara
  
        mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex,
                                                     bidirectionalLineInfoBuffer + endRemoveIndex );
  
        mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex,
                                                     bidirectionalLineInfoBuffer + endRemoveIndex );
-
-      // Clear the logical to visual and the visual to logical conversion tables.
-      CharacterIndex* logicalToVisualMapBuffer = mLogicalModel->mLogicalToVisualMap.Begin();
-      mLogicalModel->mLogicalToVisualMap.Erase( logicalToVisualMapBuffer + startIndex,
-                                                logicalToVisualMapBuffer + endIndexPlusOne );
-
-      CharacterIndex* visualToLogicalMapBuffer = mLogicalModel->mVisualToLogicalMap.Begin();
-      mLogicalModel->mVisualToLogicalMap.Erase( visualToLogicalMapBuffer + startIndex,
-                                                visualToLogicalMapBuffer + endIndexPlusOne );
      }
    }
  }
      }
    }
  }
@@ -525,7 +616,7 @@ void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, Character
    const GlyphIndex endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex );
    const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
  
    const GlyphIndex endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex );
    const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
  
-  if( SHAPE_TEXT & operations )
+  if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
    {
      // Update the character to glyph indices.
      for( Vector<GlyphIndex>::Iterator it =  charactersToGlyphBuffer + endIndexPlusOne,
    {
      // Update the character to glyph indices.
      for( Vector<GlyphIndex>::Iterator it =  charactersToGlyphBuffer + endIndexPlusOne,
@@ -577,7 +668,7 @@ void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, Character
                                           positionsBuffer + endGlyphIndexPlusOne );
    }
  
                                           positionsBuffer + endGlyphIndexPlusOne );
    }
  
-  if( LAYOUT & operations )
+  if( NO_OPERATION != ( LAYOUT & operations ) )
    {
      // Clear the lines.
      uint32_t startRemoveIndex = mVisualModel->mLines.Count();
    {
      // Clear the lines.
      uint32_t startRemoveIndex = mVisualModel->mLines.Count();
@@ -605,7 +696,7 @@ void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, Character
                                  linesBuffer + endRemoveIndex );
    }
  
                                  linesBuffer + endRemoveIndex );
    }
  
-  if( COLOR & operations )
+  if( NO_OPERATION != ( COLOR & operations ) )
    {
      if( 0u != mVisualModel->mColorIndices.Count() )
      {
    {
      if( 0u != mVisualModel->mColorIndices.Count() )
      {
@@ -667,7 +758,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
    if( mTextUpdateInfo.mClearAll ||
        ( 0u != paragraphCharacters ) )
    {
    if( mTextUpdateInfo.mClearAll ||
        ( 0u != paragraphCharacters ) )
    {
-    ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operationsRequired );
+    ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operations );
    }
  
    mTextUpdateInfo.mClearAll = false;
    }
  
    mTextUpdateInfo.mClearAll = false;
@@ -678,7 +769,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
    Vector<LineBreakInfo>& lineBreakInfo = mLogicalModel->mLineBreakInfo;
    const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters;
  
    Vector<LineBreakInfo>& lineBreakInfo = mLogicalModel->mLineBreakInfo;
    const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters;
  
-  if( GET_LINE_BREAKS & operations )
+  if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
    {
      // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
      // calculate the bidirectional info for each 'paragraph'.
    {
      // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
      // calculate the bidirectional info for each 'paragraph'.
@@ -698,7 +789,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
    }
  
    Vector<WordBreakInfo>& wordBreakInfo = mLogicalModel->mWordBreakInfo;
    }
  
    Vector<WordBreakInfo>& wordBreakInfo = mLogicalModel->mWordBreakInfo;
-  if( GET_WORD_BREAKS & operations )
+  if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
    {
      // Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines).
      wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK );
    {
      // Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines).
      wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK );
@@ -710,8 +801,8 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
      updated = true;
    }
  
      updated = true;
    }
  
-  const bool getScripts = GET_SCRIPTS & operations;
-  const bool validateFonts = VALIDATE_FONTS & operations;
+  const bool getScripts = NO_OPERATION != ( GET_SCRIPTS & operations );
+  const bool validateFonts = NO_OPERATION != ( VALIDATE_FONTS & operations );
  
    Vector<ScriptRun>& scripts = mLogicalModel->mScriptRuns;
    Vector<FontRun>& validFonts = mLogicalModel->mFontRuns;
  
    Vector<ScriptRun>& scripts = mLogicalModel->mScriptRuns;
    Vector<FontRun>& validFonts = mLogicalModel->mFontRuns;
@@ -755,7 +846,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
    Vector<Character> mirroredUtf32Characters;
    bool textMirrored = false;
    const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count();
    Vector<Character> mirroredUtf32Characters;
    bool textMirrored = false;
    const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count();
-  if( BIDI_INFO & operations )
+  if( NO_OPERATION != ( BIDI_INFO & operations ) )
    {
      Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mLogicalModel->mBidirectionalParagraphInfo;
      bidirectionalInfo.Reserve( numberOfParagraphs );
    {
      Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mLogicalModel->mBidirectionalParagraphInfo;
      bidirectionalInfo.Reserve( numberOfParagraphs );
@@ -803,7 +894,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
    newParagraphGlyphs.Reserve( numberOfParagraphs );
  
    const Length currentNumberOfGlyphs = glyphs.Count();
    newParagraphGlyphs.Reserve( numberOfParagraphs );
  
    const Length currentNumberOfGlyphs = glyphs.Count();
-  if( SHAPE_TEXT & operations )
+  if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
    {
      const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
      // Shapes the text.
    {
      const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
      // Shapes the text.
@@ -827,7 +918,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
  
    const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs;
  
  
    const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs;
  
-  if( GET_GLYPH_METRICS & operations )
+  if( NO_OPERATION != ( GET_GLYPH_METRICS & operations ) )
    {
      GlyphInfo* glyphsBuffer = glyphs.Begin();
      mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs );
    {
      GlyphInfo* glyphsBuffer = glyphs.Begin();
      mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs );
@@ -845,7 +936,7 @@ bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
      updated = true;
    }
  
      updated = true;
    }
  
-  if( COLOR & operationsRequired )
+  if( NO_OPERATION != ( COLOR & operations ) )
    {
      // Set the color runs in glyphs.
      SetColorSegmentationInfo( mLogicalModel->mColorRuns,
    {
      // Set the color runs in glyphs.
      SetColorSegmentationInfo( mLogicalModel->mColorRuns,
@@ -896,34 +987,50 @@ void Controller::Impl::RetrieveDefaultInputStyle( InputStyle& inputStyle )
    inputStyle.textColor = mTextColor;
    inputStyle.isDefaultColor = true;
  
    inputStyle.textColor = mTextColor;
    inputStyle.isDefaultColor = true;
  
+  inputStyle.familyName.clear();
+  inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
+  inputStyle.width = TextAbstraction::FontWidth::NORMAL;
+  inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
+  inputStyle.size = 0.f;
+
+  inputStyle.familyDefined = false;
+  inputStyle.weightDefined = false;
+  inputStyle.widthDefined = false;
+  inputStyle.slantDefined = false;
+  inputStyle.sizeDefined = false;
+
    // Sets the default font's family name, weight, width, slant and size.
    if( mFontDefaults )
    {
    // Sets the default font's family name, weight, width, slant and size.
    if( mFontDefaults )
    {
-    inputStyle.familyName = mFontDefaults->mFontDescription.family;
-    inputStyle.weight = mFontDefaults->mFontDescription.weight;
-    inputStyle.width = mFontDefaults->mFontDescription.width;
-    inputStyle.slant = mFontDefaults->mFontDescription.slant;
-    inputStyle.size = mFontDefaults->mDefaultPointSize;
+    if( mFontDefaults->familyDefined )
+    {
+      inputStyle.familyName = mFontDefaults->mFontDescription.family;
+      inputStyle.familyDefined = true;
+    }
  
  
-    inputStyle.familyDefined = mFontDefaults->familyDefined;
-    inputStyle.weightDefined = mFontDefaults->weightDefined;
-    inputStyle.widthDefined = mFontDefaults->widthDefined;
-    inputStyle.slantDefined = mFontDefaults->slantDefined;
-    inputStyle.sizeDefined = mFontDefaults->sizeDefined;
-  }
-  else
-  {
-    inputStyle.familyName.clear();
-    inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
-    inputStyle.width = TextAbstraction::FontWidth::NORMAL;
-    inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
-    inputStyle.size = 0.f;
+    if( mFontDefaults->weightDefined )
+    {
+      inputStyle.weight = mFontDefaults->mFontDescription.weight;
+      inputStyle.weightDefined = true;
+    }
+
+    if( mFontDefaults->widthDefined )
+    {
+      inputStyle.width = mFontDefaults->mFontDescription.width;
+      inputStyle.widthDefined = true;
+    }
  
  
-    inputStyle.familyDefined = false;
-    inputStyle.weightDefined = false;
-    inputStyle.widthDefined = false;
-    inputStyle.slantDefined = false;
-    inputStyle.sizeDefined = false;
+    if( mFontDefaults->slantDefined )
+    {
+      inputStyle.slant = mFontDefaults->mFontDescription.slant;
+      inputStyle.slantDefined = true;
+    }
+
+    if( mFontDefaults->sizeDefined )
+    {
+      inputStyle.size = mFontDefaults->mDefaultPointSize;
+      inputStyle.sizeDefined = true;
+    }
    }
  }
  
    }
  }
  
@@ -972,11 +1079,69 @@ void Controller::Impl::OnCursorKeyEvent( const Event& event )
    }
    else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
    {
    }
    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 )
    {
    }
    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;
    }
  
    mEventData->mUpdateCursorPosition = true;
@@ -994,11 +1159,18 @@ void Controller::Impl::OnTapEvent( const Event& event )
      {
        if( IsShowingRealText() )
        {
      {
        if( IsShowingRealText() )
        {
-        const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
-        const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
+        // Convert from control's coords to text's coords.
+        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 = GetClosestCursorIndex( xPosition,
-                                                                    yPosition );
+        mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel,
+                                                                          mLogicalModel,
+                                                                          mMetrics,
+                                                                          xPosition,
+                                                                          yPosition );
  
          // When the cursor position is changing, delay cursor blinking
          mEventData->mDecorator->DelayCursorBlink();
  
          // When the cursor position is changing, delay cursor blinking
          mEventData->mDecorator->DelayCursorBlink();
@@ -1009,6 +1181,7 @@ void Controller::Impl::OnTapEvent( const Event& event )
        }
  
        mEventData->mUpdateCursorPosition = true;
        }
  
        mEventData->mUpdateCursorPosition = true;
+      mEventData->mUpdateGrabHandlePosition = true;
        mEventData->mScrollAfterUpdatePosition = true;
        mEventData->mUpdateInputStyle = true;
  
        mEventData->mScrollAfterUpdatePosition = true;
        mEventData->mUpdateInputStyle = true;
  
@@ -1032,31 +1205,31 @@ void Controller::Impl::OnPanEvent( const Event& event )
  
    int state = event.p1.mInt;
  
  
    int state = event.p1.mInt;
  
-  if( Gesture::Started    == state ||
-      Gesture::Continuing == state )
+  if( ( Gesture::Started == state ) ||
+      ( Gesture::Continuing == state ) )
    {
    {
-    const Vector2& actualSize = mVisualModel->GetLayoutSize();
-    const Vector2 currentScroll = mEventData->mScrollPosition;
-
-    if( mEventData->mHorizontalScrollingEnabled )
+    if( mEventData->mDecorator )
      {
      {
-      const float displacementX = event.p2.mFloat;
-      mEventData->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;
-      mEventData->mScrollPosition.y += displacementY;
+        ClampHorizontalScroll( layoutSize );
+      }
  
  
-      ClampVerticalScroll( actualSize );
-    }
+      if( mEventData->mDecorator->IsVerticalScrollEnabled() )
+      {
+        const float displacementY = event.p3.mFloat;
+        mScrollPosition.y += displacementY;
  
  
-    if( mEventData->mDecorator )
-    {
-      mEventData->mDecorator->UpdatePositions( mEventData->mScrollPosition - currentScroll );
+        ClampVerticalScroll( layoutSize );
+      }
+
+      mEventData->mDecorator->UpdatePositions( mScrollPosition - currentScroll );
      }
    }
  }
      }
    }
  }
@@ -1082,14 +1255,20 @@ void Controller::Impl::OnHandleEvent( const Event& event )
  
    const unsigned int state = event.p1.mUint;
    const bool handleStopScrolling = ( HANDLE_STOP_SCROLLING == state );
  
    const unsigned int state = event.p1.mUint;
    const bool handleStopScrolling = ( HANDLE_STOP_SCROLLING == state );
+  const bool isSmoothHandlePanEnabled = mEventData->mDecorator->IsSmoothHandlePanEnabled();
  
    if( HANDLE_PRESSED == state )
    {
  
    if( HANDLE_PRESSED == state )
    {
-    // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
-    const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
-    const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
+    // Convert from decorator's coords to text's coords.
+    const float xPosition = event.p2.mFloat - mScrollPosition.x;
+    const float yPosition = event.p3.mFloat - mScrollPosition.y;
  
  
-    const CharacterIndex handleNewPosition = GetClosestCursorIndex( xPosition, yPosition );
+    // Need to calculate the handle's new position.
+    const CharacterIndex handleNewPosition = Text::GetClosestCursorIndex( mVisualModel,
+                                                                          mLogicalModel,
+                                                                          mMetrics,
+                                                                          xPosition,
+                                                                          yPosition );
  
      if( Event::GRAB_HANDLE_EVENT == event.type )
      {
  
      if( Event::GRAB_HANDLE_EVENT == event.type )
      {
@@ -1097,9 +1276,15 @@ void Controller::Impl::OnHandleEvent( const Event& event )
  
        if( handleNewPosition != mEventData->mPrimaryCursorPosition )
        {
  
        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;
          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 )
      {
      }
      else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
      {
@@ -1108,10 +1293,15 @@ void Controller::Impl::OnHandleEvent( const Event& event )
        if( ( handleNewPosition != mEventData->mLeftSelectionPosition ) &&
            ( handleNewPosition != mEventData->mRightSelectionPosition ) )
        {
        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->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 )
      {
      }
      else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
      {
@@ -1120,28 +1310,38 @@ void Controller::Impl::OnHandleEvent( const Event& event )
        if( ( handleNewPosition != mEventData->mRightSelectionPosition ) &&
            ( handleNewPosition != mEventData->mLeftSelectionPosition ) )
        {
        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->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;
      }
    } // end ( HANDLE_PRESSED == state )
    else if( ( HANDLE_RELEASED == state ) ||
             handleStopScrolling )
    {
      CharacterIndex handlePosition = 0u;
-    if( handleStopScrolling )
+    if( handleStopScrolling || isSmoothHandlePanEnabled )
      {
      {
-      // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
-      const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
-      const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
+      // Convert from decorator's coords to text's coords.
+      const float xPosition = event.p2.mFloat - mScrollPosition.x;
+      const float yPosition = event.p3.mFloat - mScrollPosition.y;
  
  
-      handlePosition = GetClosestCursorIndex( xPosition, yPosition );
+      handlePosition = Text::GetClosestCursorIndex( mVisualModel,
+                                                    mLogicalModel,
+                                                    mMetrics,
+                                                    xPosition,
+                                                    yPosition );
      }
  
      if( Event::GRAB_HANDLE_EVENT == event.type )
      {
        mEventData->mUpdateCursorPosition = true;
      }
  
      if( Event::GRAB_HANDLE_EVENT == event.type )
      {
        mEventData->mUpdateCursorPosition = true;
+      mEventData->mUpdateGrabHandlePosition = true;
        mEventData->mUpdateInputStyle = true;
  
        if( !IsClipboardEmpty() )
        mEventData->mUpdateInputStyle = true;
  
        if( !IsClipboardEmpty() )
@@ -1149,9 +1349,9 @@ void Controller::Impl::OnHandleEvent( const Event& event )
          ChangeState( EventData::EDITING_WITH_PASTE_POPUP ); // Moving grabhandle will show Paste Popup
        }
  
          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;
        }
      }
          mEventData->mPrimaryCursorPosition = handlePosition;
        }
      }
@@ -1159,12 +1359,15 @@ void Controller::Impl::OnHandleEvent( const Event& event )
      {
        ChangeState( EventData::SELECTING );
  
      {
        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;
          }
          {
            mEventData->mLeftSelectionPosition = handlePosition;
          }
@@ -1174,11 +1377,14 @@ void Controller::Impl::OnHandleEvent( const Event& event )
      {
        ChangeState( EventData::SELECTING );
  
      {
        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;
          }
          {
            mEventData->mRightSelectionPosition = handlePosition;
          }
@@ -1190,15 +1396,18 @@ void Controller::Impl::OnHandleEvent( const Event& event )
    else if( HANDLE_SCROLLING == state )
    {
      const float xSpeed = event.p2.mFloat;
    else if( HANDLE_SCROLLING == state )
    {
      const float xSpeed = event.p2.mFloat;
-    const Vector2& actualSize = mVisualModel->GetLayoutSize();
-    const Vector2 currentScrollPosition = mEventData->mScrollPosition;
+    const float ySpeed = event.p3.mFloat;
+    const Vector2& layoutSize = mVisualModel->GetLayoutSize();
+    const Vector2 currentScrollPosition = mScrollPosition;
  
  
-    mEventData->mScrollPosition.x += xSpeed;
+    mScrollPosition.x += xSpeed;
+    mScrollPosition.y += ySpeed;
  
  
-    ClampHorizontalScroll( actualSize );
+    ClampHorizontalScroll( layoutSize );
+    ClampVerticalScroll( layoutSize );
  
      bool endOfScroll = false;
  
      bool endOfScroll = false;
-    if( Vector2::ZERO == ( currentScrollPosition - mEventData->mScrollPosition ) )
+    if( Vector2::ZERO == ( currentScrollPosition - mScrollPosition ) )
      {
        // Notify the decorator there is no more text to scroll.
        // The decorator won't send more scroll events.
      {
        // Notify the decorator there is no more text to scroll.
        // The decorator won't send more scroll events.
@@ -1209,6 +1418,7 @@ void Controller::Impl::OnHandleEvent( const Event& event )
  
      // Set the position of the handle.
      const bool scrollRightDirection = xSpeed > 0.f;
  
      // 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;
  
      const bool leftSelectionHandleEvent = Event::LEFT_SELECTION_HANDLE_EVENT == event.type;
      const bool rightSelectionHandleEvent = Event::RIGHT_SELECTION_HANDLE_EVENT == event.type;
  
@@ -1216,53 +1426,92 @@ void Controller::Impl::OnHandleEvent( const Event& event )
      {
        ChangeState( EventData::GRAB_HANDLE_PANNING );
  
      {
        ChangeState( EventData::GRAB_HANDLE_PANNING );
  
+      // Get the grab handle position in decorator coords.
        Vector2 position = mEventData->mDecorator->GetPosition( GRAB_HANDLE );
  
        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;
+      }
  
  
-      // Get the new handle position.
-      // The grab handle's position is in decorator coords. Need to transforms to text coords.
-      const CharacterIndex handlePosition = GetClosestCursorIndex( position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x,
-                                                                   position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y );
+      if( mEventData->mDecorator->IsVerticalScrollEnabled() )
+      {
+        position.x = mEventData->mCursorHookPositionX;
  
  
-      mEventData->mUpdateCursorPosition = mEventData->mPrimaryCursorPosition != handlePosition;
-      mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateCursorPosition;
-      mEventData->mPrimaryCursorPosition = handlePosition;
+        // 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.
+      const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel,
+                                                                         mLogicalModel,
+                                                                         mMetrics,
+                                                                         position.x - mScrollPosition.x,
+                                                                         position.y - mScrollPosition.y );
+
+      if( mEventData->mPrimaryCursorPosition != handlePosition )
+      {
+        mEventData->mUpdateCursorPosition = true;
+        mEventData->mUpdateGrabHandlePosition = !isSmoothHandlePanEnabled;
+        mEventData->mScrollAfterUpdatePosition = true;
+        mEventData->mPrimaryCursorPosition = handlePosition;
+      }
        mEventData->mUpdateInputStyle = mEventData->mUpdateCursorPosition;
        mEventData->mUpdateInputStyle = mEventData->mUpdateCursorPosition;
+
+      // Updates the decorator if the soft handle panning is enabled.
+      mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
      }
      else if( leftSelectionHandleEvent || rightSelectionHandleEvent )
      {
      }
      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 );
  
        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 );
  
        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.
  
        // Get the new handle position.
-      // The selection handle's position is in decorator coords. Need to transforms to text coords.
-      const CharacterIndex handlePosition = GetClosestCursorIndex( position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x,
-                                                                   position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y );
+      // The selection handle's position is in decorator's coords. Need to transform to text's coords.
+      const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel,
+                                                                         mLogicalModel,
+                                                                         mMetrics,
+                                                                         position.x - mScrollPosition.x,
+                                                                         position.y - mScrollPosition.y );
  
        if( leftSelectionHandleEvent )
        {
          const bool differentHandles = ( mEventData->mLeftSelectionPosition != handlePosition ) && ( mEventData->mRightSelectionPosition != handlePosition );
  
        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->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;
          }
        }
            mEventData->mRightSelectionPosition = handlePosition;
          }
        }
@@ -1271,7 +1520,7 @@ void Controller::Impl::OnHandleEvent( const Event& event )
        {
          RepositionSelectionHandles();
  
        {
          RepositionSelectionHandles();
  
-        mEventData->mScrollAfterUpdatePosition = true;
+        mEventData->mScrollAfterUpdatePosition = !isSmoothHandlePanEnabled;
        }
      }
      mEventData->mDecoratorUpdated = true;
        }
      }
      mEventData->mDecoratorUpdated = true;
@@ -1288,18 +1537,13 @@ void Controller::Impl::OnSelectEvent( const Event& event )
  
    if( mEventData->mSelectionEnabled )
    {
  
    if( mEventData->mSelectionEnabled )
    {
-    // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
-    const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
-    const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
+    // Convert from control's coords to text's coords.
+    const float xPosition = event.p2.mFloat - mScrollPosition.x;
+    const float yPosition = event.p3.mFloat - mScrollPosition.y;
  
      // Calculates the logical position from the x,y coords.
      RepositionSelectionHandles( xPosition,
                                  yPosition );
  
      // Calculates the logical position from the x,y coords.
      RepositionSelectionHandles( xPosition,
                                  yPosition );
-
-    mEventData->mUpdateLeftSelectionPosition = true;
-    mEventData->mUpdateRightSelectionPosition = true;
-
-    mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
    }
  }
  
    }
  }
  
@@ -1315,12 +1559,15 @@ void Controller::Impl::OnSelectAllEvent()
  
    if( mEventData->mSelectionEnabled )
    {
  
    if( mEventData->mSelectionEnabled )
    {
+    ChangeState( EventData::SELECTING );
+
      mEventData->mLeftSelectionPosition = 0u;
      mEventData->mRightSelectionPosition = mLogicalModel->mText.Count();
  
      mEventData->mScrollAfterUpdatePosition = true;
      mEventData->mUpdateLeftSelectionPosition = true;
      mEventData->mUpdateRightSelectionPosition = true;
      mEventData->mLeftSelectionPosition = 0u;
      mEventData->mRightSelectionPosition = mLogicalModel->mText.Count();
  
      mEventData->mScrollAfterUpdatePosition = true;
      mEventData->mUpdateLeftSelectionPosition = true;
      mEventData->mUpdateRightSelectionPosition = true;
+    mEventData->mUpdateHighlightBox = true;
    }
  }
  
    }
  }
  
@@ -1364,14 +1611,15 @@ void Controller::Impl::RetrieveSelection( std::string& selectedText, bool delete
        Vector<Character>::Iterator last  = first + lengthOfSelectedText;
        utf32Characters.Erase( first, last );
  
        Vector<Character>::Iterator last  = first + lengthOfSelectedText;
        utf32Characters.Erase( first, last );
  
-      // Scroll after delete.
+      // Will show the cursor at the first character of the selection.
        mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
        mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : 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;
+    else
+    {
+      // Will show the cursor at the last character of the selection.
+      mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition;
+    }
+
      mEventData->mDecoratorUpdated = true;
    }
  }
      mEventData->mDecoratorUpdated = true;
    }
  }
@@ -1386,12 +1634,17 @@ void Controller::Impl::ShowClipboard()
  
  void Controller::Impl::HideClipboard()
  {
  
  void Controller::Impl::HideClipboard()
  {
-  if( mClipboard )
+  if( mClipboard && mClipboardHideEnabled )
    {
      mClipboard.HideClipboard();
    }
  }
  
    {
      mClipboard.HideClipboard();
    }
  }
  
+void Controller::Impl::SetClipboardHideEnable(bool enable)
+{
+  mClipboardHideEnabled = enable;
+}
+
  bool Controller::Impl::CopyStringToClipboard( std::string& source )
  {
    //Send string to clipboard
  bool Controller::Impl::CopyStringToClipboard( std::string& source )
  {
    //Send string to clipboard
@@ -1435,17 +1688,9 @@ void Controller::Impl::RepositionSelectionHandles()
    const CharacterIndex* const glyphToCharacterBuffer = mVisualModel->mGlyphsToCharacters.Begin();
    const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL;
  
    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<LineRun>& lines = mVisualModel->mLines;
-  const LineRun& firstLine = *lines.Begin();
-  const float height = firstLine.ascender + -firstLine.descender;
-
    const bool isLastCharacter = selectionEnd >= mLogicalModel->mText.Count();
    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 ) ) ) );
+  const CharacterDirection startDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + selectionStart ) );
+  const CharacterDirection 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;
  
    // Swap the indices if the start is greater than the end.
    const bool indicesSwapped = selectionStart > selectionEnd;
@@ -1464,6 +1709,48 @@ void Controller::Impl::RepositionSelectionHandles()
    const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + selectionEndMinusOne );
    const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + selectionEndMinusOne ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u );
  
    const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + selectionEndMinusOne );
    const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + selectionEndMinusOne ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u );
  
+  // Get the lines where the glyphs are laid-out.
+  const LineRun* lineRun = mVisualModel->mLines.Begin();
+
+  LineIndex lineIndex = 0u;
+  Length numberOfLines = 0u;
+  mVisualModel->GetNumberOfLines( glyphStart,
+                                  1u + glyphEnd - glyphStart,
+                                  lineIndex,
+                                  numberOfLines );
+  const LineIndex firstLineIndex = lineIndex;
+
+  // Create the structure to store some selection box info.
+  Vector<SelectionBoxInfo> selectionBoxLinesInfo;
+  selectionBoxLinesInfo.Resize( numberOfLines );
+
+  SelectionBoxInfo* selectionBoxInfo = selectionBoxLinesInfo.Begin();
+  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.
+  // However, the line descender has a negative value, hence the subtraction.
+  selectionBoxInfo->lineHeight = lineRun->ascender - lineRun->descender;
+
+  GlyphIndex lastGlyphOfLine = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1u;
+
    // 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 ) );
    // 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 ) );
@@ -1472,8 +1759,6 @@ void Controller::Impl::RepositionSelectionHandles()
    const Length numberOfCharactersEnd = *( charactersPerGlyphBuffer + glyphEnd );
    bool splitEndGlyph = ( glyphStart != glyphEnd ) && ( numberOfCharactersEnd > 1u ) && HasLigatureMustBreak( mLogicalModel->GetScript( selectionEndMinusOne ) );
  
    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 )
    {
    // Traverse the glyphs.
    for( GlyphIndex index = glyphStart; index <= glyphEnd; ++index )
    {
@@ -1497,12 +1782,18 @@ void Controller::Impl::RepositionSelectionHandles()
        // Calculate the number of characters selected.
        const Length numberOfCharacters = ( glyphStart == glyphEnd ) ? ( selectionEnd - selectionStart ) : ( numberOfCharactersStart - interGlyphIndex );
  
        // 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<float>( isCurrentRightToLeft ? ( numberOfCharactersStart - interGlyphIndex - numberOfCharacters ) : interGlyphIndex );
+      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;
+
+      // Store the min and max 'x' for each line.
+      selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
+      selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, xPositionAdvance );
  
        mEventData->mDecorator->AddHighlight( xPosition,
  
        mEventData->mDecorator->AddHighlight( xPosition,
-                                            offset.y,
-                                            xPosition + static_cast<float>( numberOfCharacters ) * glyphAdvance,
-                                            offset.y + height );
+                                            yPosition,
+                                            xPositionAdvance,
+                                            yPosition + selectionBoxInfo->lineHeight );
  
        splitStartGlyph = false;
        continue;
  
        splitStartGlyph = false;
        continue;
@@ -1523,43 +1814,210 @@ void Controller::Impl::RepositionSelectionHandles()
  
        const Length numberOfCharacters = numberOfCharactersEnd - interGlyphIndex;
  
  
        const Length numberOfCharacters = numberOfCharactersEnd - interGlyphIndex;
  
-      const float xPosition = position.x - glyph.xBearing + offset.x + ( isCurrentRightToLeft ? ( glyphAdvance * static_cast<float>( numberOfCharacters ) ) : 0.f );
+      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;
+
+      // Store the min and max 'x' for each line.
+      selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
+      selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, xPositionAdvance );
+
        mEventData->mDecorator->AddHighlight( xPosition,
        mEventData->mDecorator->AddHighlight( xPosition,
-                                            offset.y,
-                                            xPosition + static_cast<float>( interGlyphIndex ) * glyphAdvance,
-                                            offset.y + height );
+                                            yPosition,
+                                            xPositionAdvance,
+                                            yPosition + selectionBoxInfo->lineHeight );
  
        splitEndGlyph = false;
        continue;
      }
  
  
        splitEndGlyph = false;
        continue;
      }
  
-    const float xPosition = position.x - glyph.xBearing + offset.x;
+    const float xPosition = lineRun->alignmentOffset + position.x - glyph.xBearing + mScrollPosition.x;
+    const float xPositionAdvance = xPosition + glyph.advance;
+    const float yPosition = selectionBoxInfo->lineOffset;
+
+    // Store the min and max 'x' for each line.
+    selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, xPosition );
+    selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, xPositionAdvance );
+
      mEventData->mDecorator->AddHighlight( xPosition,
      mEventData->mDecorator->AddHighlight( xPosition,
-                                          offset.y,
-                                          xPosition + glyph.advance,
-                                          offset.y + height );
+                                          yPosition,
+                                          xPositionAdvance,
+                                          yPosition + selectionBoxInfo->lineHeight );
+
+    // Whether to retrieve the next line.
+    if( index == lastGlyphOfLine )
+    {
+      // Retrieve the next line.
+      ++lineRun;
+
+      // Get the last glyph of the new line.
+      lastGlyphOfLine = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1u;
+
+      ++lineIndex;
+      if( lineIndex < firstLineIndex + numberOfLines )
+      {
+        // 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;
+      }
+    }
+  }
+
+  // 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 )
+  {
+    // Boxify the first line.
+    lineRun = mVisualModel->mLines.Begin() + firstLineIndex;
+    const SelectionBoxInfo& firstSelectionBoxLineInfo = *( selectionBoxLinesInfo.Begin() );
+
+    bool boxifyBegin = ( LTR != lineRun->direction ) && ( LTR != startDirection );
+    bool boxifyEnd = ( LTR == lineRun->direction ) && ( LTR == startDirection );
+
+    if( boxifyBegin )
+    {
+      // Boxify at the beginning of the line.
+      mEventData->mDecorator->AddHighlight( 0.f,
+                                            firstSelectionBoxLineInfo.lineOffset,
+                                            firstSelectionBoxLineInfo.minX,
+                                            firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight );
+
+      // Update the size of the highlighted text.
+      minHighlightX = 0.f;
+    }
+
+    if( boxifyEnd )
+    {
+      // Boxify at the end of the line.
+      mEventData->mDecorator->AddHighlight( firstSelectionBoxLineInfo.maxX,
+                                            firstSelectionBoxLineInfo.lineOffset,
+                                            mVisualModel->mControlSize.width,
+                                            firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight );
+
+      // Update the size of the highlighted text.
+      maxHighlightX = mVisualModel->mControlSize.width;
+    }
+
+    // Boxify the central lines.
+    if( 2u < numberOfLines )
+    {
+      for( Vector<SelectionBoxInfo>::ConstIterator it = selectionBoxLinesInfo.Begin() + 1u,
+             endIt = selectionBoxLinesInfo.End() - 1u;
+           it != endIt;
+           ++it )
+      {
+        const SelectionBoxInfo& info = *it;
+
+        mEventData->mDecorator->AddHighlight( 0.f,
+                                              info.lineOffset,
+                                              info.minX,
+                                              info.lineOffset + info.lineHeight );
+
+        mEventData->mDecorator->AddHighlight( info.maxX,
+                                              info.lineOffset,
+                                              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.
+    lineRun = mVisualModel->mLines.Begin() + firstLineIndex + numberOfLines - 1u;
+    const SelectionBoxInfo& lastSelectionBoxLineInfo = *( selectionBoxLinesInfo.End() - 1u );
+
+    boxifyBegin = ( LTR == lineRun->direction ) && ( LTR == endDirection );
+    boxifyEnd = ( LTR != lineRun->direction ) && ( LTR != endDirection );
+
+    if( boxifyBegin )
+    {
+      // Boxify at the beginning of the line.
+      mEventData->mDecorator->AddHighlight( 0.f,
+                                            lastSelectionBoxLineInfo.lineOffset,
+                                            lastSelectionBoxLineInfo.minX,
+                                            lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight );
+
+      // Update the size of the highlighted text.
+      minHighlightX = 0.f;
+    }
+
+    if( boxifyEnd )
+    {
+      // Boxify at the end of the line.
+      mEventData->mDecorator->AddHighlight( lastSelectionBoxLineInfo.maxX,
+                                            lastSelectionBoxLineInfo.lineOffset,
+                                            mVisualModel->mControlSize.width,
+                                            lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight );
+
+      // Update the size of the highlighted text.
+      maxHighlightX = mVisualModel->mControlSize.width;
+    }
    }
  
    }
  
-  CursorInfo primaryCursorInfo;
-  GetCursorPosition( mEventData->mLeftSelectionPosition,
-                     primaryCursorInfo );
+  // 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 );
+
+    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 + offset;
-  const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + offset;
+    CursorInfo secondaryCursorInfo;
+    GetCursorPosition( mEventData->mRightSelectionPosition,
+                       secondaryCursorInfo );
  
  
-  mEventData->mDecorator->SetPosition( LEFT_SELECTION_HANDLE,
-                                       primaryPosition.x,
-                                       primaryCursorInfo.lineOffset + offset.y,
-                                       primaryCursorInfo.lineHeight );
+    const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + mScrollPosition;
  
  
-  mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE,
-                                       secondaryPosition.x,
-                                       secondaryCursorInfo.lineOffset + offset.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;
  
    // 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;
@@ -1594,23 +2052,45 @@ void Controller::Impl::RepositionSelectionHandles( float visualX, float visualY
    // Find which word was selected
    CharacterIndex selectionStart( 0 );
    CharacterIndex selectionEnd( 0 );
    // Find which word was selected
    CharacterIndex selectionStart( 0 );
    CharacterIndex selectionEnd( 0 );
-  FindSelectionIndices( 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 );
  
    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->mLeftSelectionPosition = selectionStart;
+    mEventData->mRightSelectionPosition = selectionEnd;
  
  
-void Controller::Impl::SetPopupButtons()
-{
-  /**
+    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->mUpdateCursorPosition = true;
+    mEventData->mUpdateGrabHandlePosition = true;
+    mEventData->mScrollAfterUpdatePosition = true;
+    mEventData->mUpdateInputStyle = true;
+  }
+}
+
+void Controller::Impl::SetPopupButtons()
+{
+  /**
     *  Sets the Popup buttons to be shown depending on State.
     *
     *  If SELECTING :  CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
     *  Sets the Popup buttons to be shown depending on State.
     *
     *  If SELECTING :  CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
@@ -1674,369 +2154,175 @@ void Controller::Impl::ChangeState( EventData::State newState )
    {
      mEventData->mState = newState;
  
    {
      mEventData->mState = newState;
  
-    if( EventData::INACTIVE == mEventData->mState )
+    switch( mEventData->mState )
      {
      {
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-      mEventData->mDecorator->StopCursorBlink();
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetPopupActive( false );
-      mEventData->mDecoratorUpdated = true;
-      HideClipboard();
-    }
-    else if( EventData::INTERRUPTED  == mEventData->mState)
-    {
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetPopupActive( false );
-      mEventData->mDecoratorUpdated = true;
-      HideClipboard();
-    }
-    else if( EventData::SELECTING == mEventData->mState )
-    {
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-      mEventData->mDecorator->StopCursorBlink();
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
-      if( mEventData->mGrabHandlePopupEnabled )
+      case EventData::INACTIVE:
        {
        {
-        SetPopupButtons();
-        mEventData->mDecorator->SetPopupActive( true );
-      }
-      mEventData->mDecoratorUpdated = true;
-    }
-    else if( EventData::EDITING == mEventData->mState )
-    {
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      if( mEventData->mCursorBlinkEnabled )
-      {
-        mEventData->mDecorator->StartCursorBlink();
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
+        mEventData->mDecorator->StopCursorBlink();
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetPopupActive( false );
+        mEventData->mDecoratorUpdated = true;
+        HideClipboard();
+        break;
        }
        }
-      // Grab handle is not shown until a tap is received whilst EDITING
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-      if( mEventData->mGrabHandlePopupEnabled )
+      case EventData::INTERRUPTED:
        {
        {
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
          mEventData->mDecorator->SetPopupActive( false );
          mEventData->mDecorator->SetPopupActive( false );
+        mEventData->mDecoratorUpdated = true;
+        HideClipboard();
+        break;
        }
        }
-      mEventData->mDecoratorUpdated = true;
-      HideClipboard();
-    }
-    else if( EventData::EDITING_WITH_POPUP == mEventData->mState )
-    {
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState );
-
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      if( mEventData->mCursorBlinkEnabled )
+      case EventData::SELECTING:
        {
        {
-        mEventData->mDecorator->StartCursorBlink();
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
+        mEventData->mDecorator->StopCursorBlink();
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          SetPopupButtons();
+          mEventData->mDecorator->SetPopupActive( true );
+        }
+        mEventData->mDecoratorUpdated = true;
+        break;
        }
        }
-      if( mEventData->mSelectionEnabled )
+      case EventData::EDITING:
        {
        {
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+        if( mEventData->mCursorBlinkEnabled )
+        {
+          mEventData->mDecorator->StartCursorBlink();
+        }
+        // Grab handle is not shown until a tap is received whilst EDITING
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
          mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
          mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
          mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
          mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          mEventData->mDecorator->SetPopupActive( false );
+        }
+        mEventData->mDecoratorUpdated = true;
+        HideClipboard();
+        break;
        }
        }
-      else
-      {
-        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
-      }
-      if( mEventData->mGrabHandlePopupEnabled )
+      case EventData::EDITING_WITH_POPUP:
        {
        {
-        SetPopupButtons();
-        mEventData->mDecorator->SetPopupActive( true );
-      }
-      HideClipboard();
-      mEventData->mDecoratorUpdated = true;
-    }
-    else if( EventData::EDITING_WITH_GRAB_HANDLE == mEventData->mState )
-    {
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState );
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState );
  
  
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      if( mEventData->mCursorBlinkEnabled )
-      {
-        mEventData->mDecorator->StartCursorBlink();
-      }
-      // Grab handle is not shown until a tap is received whilst EDITING
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-      if( mEventData->mGrabHandlePopupEnabled )
-      {
-        mEventData->mDecorator->SetPopupActive( false );
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+        if( mEventData->mCursorBlinkEnabled )
+        {
+          mEventData->mDecorator->StartCursorBlink();
+        }
+        if( mEventData->mSelectionEnabled )
+        {
+          mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+          mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+        }
+        else
+        {
+          mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        }
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          SetPopupButtons();
+          mEventData->mDecorator->SetPopupActive( true );
+        }
+        HideClipboard();
+        mEventData->mDecoratorUpdated = true;
+        break;
        }
        }
-      mEventData->mDecoratorUpdated = true;
-      HideClipboard();
-    }
-    else if( EventData::SELECTION_HANDLE_PANNING == mEventData->mState )
-    {
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-      mEventData->mDecorator->StopCursorBlink();
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
-      if( mEventData->mGrabHandlePopupEnabled )
+      case EventData::EDITING_WITH_GRAB_HANDLE:
        {
        {
-        mEventData->mDecorator->SetPopupActive( false );
-      }
-      mEventData->mDecoratorUpdated = true;
-    }
-    else if( EventData::GRAB_HANDLE_PANNING == mEventData->mState )
-    {
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState );
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState );
  
  
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      if( mEventData->mCursorBlinkEnabled )
-      {
-        mEventData->mDecorator->StartCursorBlink();
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+        if( mEventData->mCursorBlinkEnabled )
+        {
+          mEventData->mDecorator->StartCursorBlink();
+        }
+        // Grab handle is not shown until a tap is received whilst EDITING
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          mEventData->mDecorator->SetPopupActive( false );
+        }
+        mEventData->mDecoratorUpdated = true;
+        HideClipboard();
+        break;
        }
        }
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-      if( mEventData->mGrabHandlePopupEnabled )
+      case EventData::SELECTION_HANDLE_PANNING:
        {
        {
-        mEventData->mDecorator->SetPopupActive( false );
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
+        mEventData->mDecorator->StopCursorBlink();
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          mEventData->mDecorator->SetPopupActive( false );
+        }
+        mEventData->mDecoratorUpdated = true;
+        break;
        }
        }
-      mEventData->mDecoratorUpdated = true;
-    }
-    else if( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
-    {
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState );
-
-      mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      if( mEventData->mCursorBlinkEnabled )
+      case EventData::GRAB_HANDLE_PANNING:
        {
        {
-        mEventData->mDecorator->StartCursorBlink();
-      }
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState );
  
  
-      mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
-      mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
-      mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
-
-      if( mEventData->mGrabHandlePopupEnabled )
-      {
-        SetPopupButtons();
-        mEventData->mDecorator->SetPopupActive( true );
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+        if( mEventData->mCursorBlinkEnabled )
+        {
+          mEventData->mDecorator->StartCursorBlink();
+        }
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          mEventData->mDecorator->SetPopupActive( false );
+        }
+        mEventData->mDecoratorUpdated = true;
+        break;
        }
        }
-      HideClipboard();
-      mEventData->mDecoratorUpdated = true;
-    }
-  }
-}
-
-LineIndex Controller::Impl::GetClosestLine( float y ) const
-{
-  float totalHeight = 0.f;
-  LineIndex lineIndex = 0u;
-
-  const Vector<LineRun>& lines = mVisualModel->mLines;
-  for( LineIndex endLine = lines.Count();
-       lineIndex < endLine;
-       ++lineIndex )
-  {
-    const LineRun& lineRun = lines[lineIndex];
-    totalHeight += lineRun.ascender + -lineRun.descender;
-    if( y < totalHeight )
-    {
-      return lineIndex;
-    }
-  }
-
-  if( lineIndex == 0 )
-  {
-    return 0;
-  }
-
-  return lineIndex-1;
-}
-
-void Controller::Impl::FindSelectionIndices( float visualX, float visualY, CharacterIndex& startIndex, CharacterIndex& endIndex )
-{
-  CharacterIndex hitCharacter = GetClosestCursorIndex( visualX, visualY );
-  DALI_ASSERT_DEBUG( hitCharacter <= mLogicalModel->mText.Count() && "GetClosestCursorIndex returned out of bounds index" );
-
-  if( mLogicalModel->mText.Count() == 0 )
-  {
-    return;  // if model empty
-  }
-
-  if( hitCharacter >= mLogicalModel->mText.Count() )
-  {
-    // Closest hit character is the last character.
-    if( hitCharacter ==  mLogicalModel->mText.Count() )
-    {
-      hitCharacter--; //Hit character index set to last character in logical model
-    }
-    else
-    {
-      // hitCharacter is out of bounds
-      return;
-    }
-  }
-
-  startIndex = hitCharacter;
-  endIndex = hitCharacter;
-  bool isHitCharacterWhitespace = TextAbstraction::IsWhiteSpace( mLogicalModel->mText[hitCharacter] );
-
-  // Find the start and end of the text
-  for( startIndex = hitCharacter; startIndex > 0; --startIndex )
-  {
-    if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ startIndex-1 ] ) )
-    {
-      break;
-    }
-  }
-  const CharacterIndex pastTheEnd = mLogicalModel->mText.Count();
-  for( endIndex = hitCharacter + 1u; endIndex < pastTheEnd; ++endIndex )
-  {
-    if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ endIndex ] ) )
-    {
-      break;
-    }
-  }
-}
-
-CharacterIndex Controller::Impl::GetClosestCursorIndex( float visualX,
-                                                        float visualY )
-{
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetClosestCursorIndex %p closest visualX %f visualY %f\n", this, visualX, visualY );
-
-  if( NULL == mEventData )
-  {
-    // Nothing to do if there is no text input.
-    return 0u;
-  }
-
-  CharacterIndex logicalIndex = 0u;
-
-  const Length numberOfGlyphs = mVisualModel->mGlyphs.Count();
-  const Length numberOfLines  = mVisualModel->mLines.Count();
-  if( ( 0 == numberOfGlyphs ) ||
-      ( 0 == numberOfLines ) )
-  {
-    return logicalIndex;
-  }
-
-  // Find which line is closest
-  const LineIndex lineIndex = GetClosestLine( visualY );
-  const LineRun& line = mVisualModel->mLines[lineIndex];
-
-  // Get the positions of the glyphs.
-  const Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
-  const Vector2* const positionsBuffer = positions.Begin();
-
-  // Get the visual to logical conversion tables.
-  const CharacterIndex* const visualToLogicalBuffer = ( 0u != mLogicalModel->mVisualToLogicalMap.Count() ) ? mLogicalModel->mVisualToLogicalMap.Begin() : NULL;
-  const CharacterIndex* const visualToLogicalCursorBuffer = mLogicalModel->mVisualToLogicalCursorMap.Begin();
-
-  // Get the character to glyph conversion table.
-  const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
-
-  // Get the glyphs per character table.
-  const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
-
-  // Get the glyph's info buffer.
-  const GlyphInfo* const glyphInfoBuffer = mVisualModel->mGlyphs.Begin();
-
-  // If the vector is void, there is no right to left characters.
-  const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer;
-
-  const CharacterIndex startCharacter = line.characterRun.characterIndex;
-  const CharacterIndex endCharacter   = line.characterRun.characterIndex + line.characterRun.numberOfCharacters;
-  DALI_ASSERT_DEBUG( endCharacter <= mLogicalModel->mText.Count() && "Invalid line info" );
-
-  // Whether there is a hit on a glyph.
-  bool matched = false;
-
-  // Traverses glyphs in visual order. To do that use the visual to logical conversion table.
-  CharacterIndex visualIndex = startCharacter;
-  Length numberOfCharacters = 0u;
-  for( ; !matched && ( visualIndex < endCharacter ); ++visualIndex )
-  {
-    // The character in logical order.
-    const CharacterIndex characterLogicalOrderIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + visualIndex ) : visualIndex;
-
-    // Get the script of the character.
-    const Script script = mLogicalModel->GetScript( characterLogicalOrderIndex );
-
-    // The number of glyphs for that character
-    const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex );
-    ++numberOfCharacters;
-
-
-    if( 0u != numberOfGlyphs )
-    {
-      // Get the first character/glyph of the group of glyphs.
-      const CharacterIndex firstVisualCharacterIndex = 1u + visualIndex - numberOfCharacters;
-      const CharacterIndex firstLogicalCharacterIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + firstVisualCharacterIndex ) : firstVisualCharacterIndex;
-      const GlyphIndex firstLogicalGlyphIndex = *( charactersToGlyphBuffer + firstLogicalCharacterIndex );
-
-      // Get the metrics for the group of glyphs.
-      GlyphMetrics glyphMetrics;
-      GetGlyphsMetrics( firstLogicalGlyphIndex,
-                        numberOfGlyphs,
-                        glyphMetrics,
-                        glyphInfoBuffer,
-                        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<float>( numberOfBlocks );
-
-      GlyphIndex index = 0u;
-      for( ; !matched && ( index < numberOfBlocks ); ++index )
+      case EventData::EDITING_WITH_PASTE_POPUP:
        {
        {
-        // Find the mid-point of the area containing the glyph
-        const float glyphCenter = -glyphMetrics.xBearing + position.x + ( static_cast<float>( index ) + 0.5f ) * glyphAdvance;
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState );
  
  
-        if( visualX < glyphCenter )
+        mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+        if( mEventData->mCursorBlinkEnabled )
          {
          {
-          matched = true;
-          break;
+          mEventData->mDecorator->StartCursorBlink();
          }
          }
-      }
  
  
-      if( matched )
-      {
-        visualIndex = firstVisualCharacterIndex + index;
+        mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+        mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+
+        if( mEventData->mGrabHandlePopupEnabled )
+        {
+          SetPopupButtons();
+          mEventData->mDecorator->SetPopupActive( true );
+        }
+        HideClipboard();
+        mEventData->mDecoratorUpdated = true;
          break;
        }
          break;
        }
-
-      numberOfCharacters = 0u;
      }
      }
-
-  }
-
-
-  // Return the logical position of the cursor in characters.
-
-  if( !matched )
-  {
-    visualIndex = endCharacter;
    }
    }
-
-  logicalIndex = hasRightToLeftCharacters ? *( visualToLogicalCursorBuffer + visualIndex ) : visualIndex;
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p closest visualIndex %d logicalIndex %d\n", this, visualIndex, logicalIndex );
-
-  DALI_ASSERT_DEBUG( ( logicalIndex <= mLogicalModel->mText.Count() && logicalIndex >= 0 ) && "GetClosestCursorIndex - Out of bounds index" );
-
-  return logicalIndex;
  }
  
  void Controller::Impl::GetCursorPosition( CharacterIndex logical,
                                            CursorInfo& cursorInfo )
  {
  }
  
  void Controller::Impl::GetCursorPosition( CharacterIndex logical,
                                            CursorInfo& cursorInfo )
  {
-  // TODO: Check for multiline with \n, etc...
-
-  const Length numberOfCharacters = mLogicalModel->mText.Count();
    if( !IsShowingRealText() )
    {
      // Do not want to use the place-holder text to set the cursor position.
    if( !IsShowingRealText() )
    {
      // Do not want to use the place-holder text to set the cursor position.
@@ -2068,206 +2354,15 @@ void Controller::Impl::GetCursorPosition( CharacterIndex logical,
        }
      }
  
        }
      }
  
-    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;
    }
  
      // 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;
-  const CharacterIndex characterIndex = isFirstPosition ? logical : logical - 1u;
-
-  // Get the direction of the character and the next one.
-  const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL;
-
-  CharacterDirection isCurrentRightToLeft = false;
-  CharacterDirection isNextRightToLeft = false;
-  if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
-  {
-    isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + characterIndex );
-    isNextRightToLeft = *( modelCharacterDirectionsBuffer + nextCharacterIndex );
-  }
-
-  // Get the line where the character is laid-out.
-  const LineRun* const modelLines = mVisualModel->mLines.Begin();
-
-  const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( characterIndex );
-  const LineRun& line = *( modelLines + lineIndex );
-
-  // Get the paragraph's direction.
-  const CharacterDirection isRightToLeftParagraph = line.direction;
-
-  // Check whether there is an alternative position:
-
-  cursorInfo.isSecondaryCursor = ( !isLastPosition && ( isCurrentRightToLeft != isNextRightToLeft ) ) ||
-                                 ( isLastPosition && ( isRightToLeftParagraph != isCurrentRightToLeft ) );
-
-  // Set the line offset and height.
-  cursorInfo.lineOffset = 0.f;
-  cursorInfo.lineHeight = line.ascender + -line.descender;
-
-  // Calculate the primary cursor.
-
-  CharacterIndex index = characterIndex;
-  if( cursorInfo.isSecondaryCursor )
-  {
-    // If there is a secondary position, the primary cursor may be in a different place than the logical index.
-
-    if( isLastPosition )
-    {
-      // The position of the cursor after the last character needs special
-      // care depending on its direction and the direction of the paragraph.
-
-      // Need to find the first character after the last character with the paragraph's direction.
-      // i.e l0 l1 l2 r0 r1 should find r0.
-
-      // TODO: check for more than one line!
-      index = isRightToLeftParagraph ? line.characterRun.characterIndex : line.characterRun.characterIndex + line.characterRun.numberOfCharacters - 1u;
-      index = mLogicalModel->GetLogicalCharacterIndex( index );
-    }
-    else
-    {
-      index = ( isRightToLeftParagraph == isCurrentRightToLeft ) ? characterIndex : nextCharacterIndex;
-    }
-  }
-
-  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();
-  const GlyphInfo* const glyphInfoBuffer = mVisualModel->mGlyphs.Begin();
-
-  // Convert the cursor position into the glyph position.
-  const GlyphIndex primaryGlyphIndex = *( charactersToGlyphBuffer + index );
-  const Length primaryNumberOfGlyphs = *( glyphsPerCharacterBuffer + index );
-  const Length primaryNumberOfCharacters = *( charactersPerGlyphBuffer + primaryGlyphIndex );
-
-  // Get the metrics for the group of glyphs.
-  GlyphMetrics glyphMetrics;
-  GetGlyphsMetrics( primaryGlyphIndex,
-                    primaryNumberOfGlyphs,
-                    glyphMetrics,
-                    glyphInfoBuffer,
-                    mMetrics );
-
-  // Whether to add the glyph's advance to the cursor position.
-  // i.e if the paragraph is left to right and the logical cursor is zero, the position is the position of the first glyph and the advance is not added,
-  //     if the logical cursor is one, the position is the position of the first glyph and the advance is added.
-  // A 'truth table' was build and an online Karnaugh map tool was used to simplify the logic.
-  //
-  // FLCP A
-  // ------
-  // 0000 1
-  // 0001 1
-  // 0010 0
-  // 0011 0
-  // 0100 1
-  // 0101 0
-  // 0110 1
-  // 0111 0
-  // 1000 0
-  // 1001 x
-  // 1010 x
-  // 1011 1
-  // 1100 x
-  // 1101 x
-  // 1110 x
-  // 1111 x
-  //
-  // Where F -> isFirstPosition
-  //       L -> isLastPosition
-  //       C -> isCurrentRightToLeft
-  //       P -> isRightToLeftParagraph
-  //       A -> Whether to add the glyph's advance.
-
-  const bool addGlyphAdvance = ( ( isLastPosition && !isRightToLeftParagraph ) ||
-                                 ( isFirstPosition && isRightToLeftParagraph ) ||
-                                 ( !isFirstPosition && !isLastPosition && !isCurrentRightToLeft ) );
-
-  float glyphAdvance = addGlyphAdvance ? glyphMetrics.advance : 0.f;
-
-  if( !isLastPosition &&
-      ( primaryNumberOfCharacters > 1u ) )
-  {
-    const CharacterIndex firstIndex = *( glyphsToCharactersBuffer + primaryGlyphIndex );
-
-    bool isCurrentRightToLeft = false;
-    if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
-    {
-      isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + index );
-    }
-
-    Length numberOfGlyphAdvance = ( isFirstPosition ? 0u : 1u ) + characterIndex - firstIndex;
-    if( isCurrentRightToLeft )
-    {
-      numberOfGlyphAdvance = primaryNumberOfCharacters - numberOfGlyphAdvance;
-    }
-
-    glyphAdvance = static_cast<float>( numberOfGlyphAdvance ) * glyphMetrics.advance / static_cast<float>( primaryNumberOfCharacters );
-  }
-
-  // Get the glyph position and x bearing.
-  const Vector2& primaryPosition = *( glyphPositionsBuffer + primaryGlyphIndex );
-
-  // Set the primary cursor's height.
-  cursorInfo.primaryCursorHeight = cursorInfo.isSecondaryCursor ? 0.5f * glyphMetrics.fontHeight : glyphMetrics.fontHeight;
-
-  // Set the primary cursor's position.
-  cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + primaryPosition.x + glyphAdvance;
-  cursorInfo.primaryPosition.y = line.ascender - glyphMetrics.ascender;
-
-  // Calculate the secondary cursor.
-
-  if( cursorInfo.isSecondaryCursor )
-  {
-    // Set the secondary cursor's height.
-    cursorInfo.secondaryCursorHeight = 0.5f * glyphMetrics.fontHeight;
-
-    CharacterIndex index = characterIndex;
-    if( !isLastPosition )
-    {
-      index = ( isRightToLeftParagraph == isCurrentRightToLeft ) ? nextCharacterIndex : characterIndex;
-    }
-
-    const GlyphIndex secondaryGlyphIndex = *( charactersToGlyphBuffer + index );
-    const Length secondaryNumberOfGlyphs = *( glyphsPerCharacterBuffer + index );
-
-    const Vector2& secondaryPosition = *( glyphPositionsBuffer + secondaryGlyphIndex );
-
-    GetGlyphsMetrics( secondaryGlyphIndex,
-                      secondaryNumberOfGlyphs,
-                      glyphMetrics,
-                      glyphInfoBuffer,
-                      mMetrics );
-
-    // Set the secondary cursor's position.
-    cursorInfo.secondaryPosition.x = -glyphMetrics.xBearing + secondaryPosition.x + ( isCurrentRightToLeft ? 0.f : glyphMetrics.advance );
-    cursorInfo.secondaryPosition.y = cursorInfo.lineHeight - cursorInfo.secondaryCursorHeight - line.descender - ( glyphMetrics.fontHeight - glyphMetrics.ascender );
-  }
+  Text::GetCursorPosition( mVisualModel,
+                           mLogicalModel,
+                           mMetrics,
+                           logical,
+                           cursorInfo );
  
    if( LayoutEngine::MULTI_LINE_BOX == mLayoutEngine.GetLayout() )
    {
  
    if( LayoutEngine::MULTI_LINE_BOX == mLayoutEngine.GetLayout() )
    {
@@ -2332,6 +2427,9 @@ CharacterIndex Controller::Impl::CalculateNewCursorIndex( CharacterIndex index )
      cursorIndex += numberOfCharacters;
    }
  
      cursorIndex += numberOfCharacters;
    }
  
+  // Will update the cursor hook position.
+  mEventData->mUpdateCursorHookPosition = true;
+
    return cursorIndex;
  }
  
    return cursorIndex;
  }
  
@@ -2345,8 +2443,7 @@ void Controller::Impl::UpdateCursorPosition( const CursorInfo& cursorInfo )
      return;
    }
  
      return;
    }
  
-  const Vector2 offset = mEventData->mScrollPosition + ( IsShowingRealText() ? mAlignmentOffset : Vector2::ZERO );
-  const Vector2 cursorPosition = cursorInfo.primaryPosition + offset;
+  const Vector2 cursorPosition = cursorInfo.primaryPosition + mScrollPosition;
  
    // Sets the cursor position.
    mEventData->mDecorator->SetPosition( PRIMARY_CURSOR,
  
    // Sets the cursor position.
    mEventData->mDecorator->SetPosition( PRIMARY_CURSOR,
@@ -2356,20 +2453,23 @@ void Controller::Impl::UpdateCursorPosition( const CursorInfo& cursorInfo )
                                         cursorInfo.lineHeight );
    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y );
  
                                         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 + offset.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 )
    {
      mEventData->mDecorator->SetPosition( SECONDARY_CURSOR,
  
    if( cursorInfo.isSecondaryCursor )
    {
      mEventData->mDecorator->SetPosition( SECONDARY_CURSOR,
-                                         cursorInfo.secondaryPosition.x + offset.x,
-                                         cursorInfo.secondaryPosition.y + offset.y,
+                                         cursorInfo.secondaryPosition.x + mScrollPosition.x,
+                                         cursorInfo.secondaryPosition.y + mScrollPosition.y,
                                           cursorInfo.secondaryCursorHeight,
                                           cursorInfo.lineHeight );
                                           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 );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + mScrollPosition.x, cursorInfo.secondaryPosition.y + mScrollPosition.y );
    }
  
    // Set which cursors are active according the state.
    }
  
    // Set which cursors are active according the state.
@@ -2401,13 +2501,12 @@ void Controller::Impl::UpdateSelectionHandle( HandleType handleType,
      return;
    }
  
      return;
    }
  
-  const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset;
-  const Vector2 cursorPosition = cursorInfo.primaryPosition + offset;
+  const Vector2 cursorPosition = cursorInfo.primaryPosition + mScrollPosition;
  
    // Sets the handle's position.
    mEventData->mDecorator->SetPosition( handleType,
                                         cursorPosition.x,
  
    // Sets the handle's position.
    mEventData->mDecorator->SetPosition( handleType,
                                         cursorPosition.x,
-                                       cursorInfo.lineOffset + offset.y,
+                                       cursorInfo.lineOffset + mScrollPosition.y,
                                         cursorInfo.lineHeight );
  
    // If selection handle at start of the text and other at end of the text then all text is selected.
                                         cursorInfo.lineHeight );
  
    // If selection handle at start of the text and other at end of the text then all text is selected.
@@ -2416,59 +2515,72 @@ void Controller::Impl::UpdateSelectionHandle( HandleType handleType,
    mEventData->mAllTextSelected = ( startOfSelection == 0 ) && ( endOfSelection == mLogicalModel->mText.Count() );
  }
  
    mEventData->mAllTextSelected = ( startOfSelection == 0 ) && ( endOfSelection == mLogicalModel->mText.Count() );
  }
  
-void Controller::Impl::ClampHorizontalScroll( const Vector2& actualSize )
+void Controller::Impl::ClampHorizontalScroll( const Vector2& layoutSize )
  {
  {
-  // Clamp between -space & 0 (and the text alignment).
+  // Clamp between -space & 0.
  
  
-  if( actualSize.width > mVisualModel->mControlSize.width )
+  if( layoutSize.width > mVisualModel->mControlSize.width )
    {
    {
-    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;
+    const float space = ( layoutSize.width - mVisualModel->mControlSize.width );
+    mScrollPosition.x = ( mScrollPosition.x < -space ) ? -space : mScrollPosition.x;
+    mScrollPosition.x = ( mScrollPosition.x > 0.f ) ? 0.f : mScrollPosition.x;
  
      mEventData->mDecoratorUpdated = true;
    }
    else
    {
  
      mEventData->mDecoratorUpdated = true;
    }
    else
    {
-    mEventData->mScrollPosition.x = 0.f;
+    mScrollPosition.x = 0.f;
    }
  }
  
    }
  }
  
-void Controller::Impl::ClampVerticalScroll( const Vector2& actualSize )
+void Controller::Impl::ClampVerticalScroll( const Vector2& layoutSize )
  {
  {
-  // Clamp between -space & 0 (and the text alignment).
-  if( actualSize.height > mVisualModel->mControlSize.height )
+  // Clamp between -space & 0.
+  if( layoutSize.height > mVisualModel->mControlSize.height )
    {
    {
-    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;
+    const float space = ( layoutSize.height - mVisualModel->mControlSize.height );
+    mScrollPosition.y = ( mScrollPosition.y < -space ) ? -space : mScrollPosition.y;
+    mScrollPosition.y = ( mScrollPosition.y > 0.f ) ? 0.f : mScrollPosition.y;
  
      mEventData->mDecoratorUpdated = true;
    }
    else
    {
  
      mEventData->mDecoratorUpdated = true;
    }
    else
    {
-    mEventData->mScrollPosition.y = 0.f;
+    mScrollPosition.y = 0.f;
    }
  }
  
    }
  }
  
-void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position )
+void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position, float lineHeight )
  {
  {
+  const float cursorWidth = mEventData->mDecorator ? static_cast<float>( mEventData->mDecorator->GetCursorWidth() ) : 0.f;
+
    // position is in actor's coords.
    // position is in actor's coords.
-  const float positionEnd = position.x + ( mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f );
+  const float positionEndX = position.x + cursorWidth;
+  const float positionEndY = position.y + lineHeight;
  
    // Transform the position to decorator coords.
  
    // Transform the position to decorator coords.
-  const float alignment = IsShowingRealText() ? mAlignmentOffset.x : 0.f;
-  const float offset = mEventData->mScrollPosition.x + alignment;
-  const float decoratorPositionBegin = position.x + offset;
-  const float decoratorPositionEnd = positionEnd + offset;
+  const float decoratorPositionBeginX = position.x + mScrollPosition.x;
+  const float decoratorPositionEndX = positionEndX + mScrollPosition.x;
+
+  const float decoratorPositionBeginY = position.y + mScrollPosition.y;
+  const float decoratorPositionEndY = positionEndY + mScrollPosition.y;
+
+  if( decoratorPositionBeginX < 0.f )
+  {
+    mScrollPosition.x = -position.x;
+  }
+  else if( decoratorPositionEndX > mVisualModel->mControlSize.width )
+  {
+    mScrollPosition.x = mVisualModel->mControlSize.width - positionEndX;
+  }
  
  
-  if( decoratorPositionBegin < 0.f )
+  if( decoratorPositionBeginY < 0.f )
    {
    {
-    mEventData->mScrollPosition.x = -position.x - alignment;
+    mScrollPosition.y = -position.y;
    }
    }
-  else if( decoratorPositionEnd > mVisualModel->mControlSize.width )
+  else if( decoratorPositionEndY > mVisualModel->mControlSize.height )
    {
    {
-    mEventData->mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd - alignment;
+    mScrollPosition.y = mVisualModel->mControlSize.height - positionEndY;
    }
  }
  
    }
  }
  
@@ -2478,9 +2590,14 @@ void Controller::Impl::ScrollTextToMatchCursor( const CursorInfo& cursorInfo )
    const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
  
    // Calculate the offset to match the cursor position before the character was deleted.
    const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
  
    // Calculate the offset to match the cursor position before the character was deleted.
-  mEventData->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x - mAlignmentOffset.x;
+  mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x;
+  mScrollPosition.y = currentCursorPosition.y - cursorInfo.lineOffset;
  
    ClampHorizontalScroll( mVisualModel->GetLayoutSize() );
  
    ClampHorizontalScroll( mVisualModel->GetLayoutSize() );
+  ClampVerticalScroll( mVisualModel->GetLayoutSize() );
+
+  // Makes the new cursor position visible if needed.
+  ScrollToMakePositionVisible( cursorInfo.primaryPosition, cursorInfo.lineHeight );
  }
  
  void Controller::Impl::RequestRelayout()
  }
  
  void Controller::Impl::RequestRelayout()