X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-controller.cpp;h=814c4fe3e10beca408916245375068ff29ea91e4;hp=2a3631fe8bd45d5d15e394f6f0ee8454f3226d11;hb=77c9237f0924c5947ecb2a2981a133f7634f723d;hpb=c25b3c40178dadf12dc5e8f77c17413df0a55099

diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp
index 2a3631f..814c4fe 100644
--- a/dali-toolkit/internal/text/text-controller.cpp
+++ b/dali-toolkit/internal/text/text-controller.cpp
@@ -20,45 +20,39 @@
 
 // EXTERNAL INCLUDES
 #include <limits>
-#include <vector>
+#include <iostream>
 #include <dali/public-api/adaptor-framework/key.h>
-#include <dali/public-api/text-abstraction/font-client.h>
+#include <dali/integration-api/debug.h>
+#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.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/layouts/layout-engine.h>
 #include <dali-toolkit/internal/text/layouts/layout-parameters.h>
-#include <dali-toolkit/internal/text/logical-model-impl.h>
 #include <dali-toolkit/internal/text/multi-language-support.h>
 #include <dali-toolkit/internal/text/script-run.h>
 #include <dali-toolkit/internal/text/segmentation.h>
 #include <dali-toolkit/internal/text/shaper.h>
+#include <dali-toolkit/internal/text/text-controller-impl.h>
 #include <dali-toolkit/internal/text/text-io.h>
 #include <dali-toolkit/internal/text/text-view.h>
-#include <dali-toolkit/internal/text/visual-model-impl.h>
-
-using std::vector;
 
 namespace
 {
 
+#if defined(DEBUG_ENABLED)
+  Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
+#endif
+
 const float MAX_FLOAT = std::numeric_limits<float>::max();
 
-enum ModifyType
-{
-  REPLACE_TEXT, ///< Replace the entire text
-  INSERT_TEXT,  ///< Insert characters at the current cursor position
-  DELETE_TEXT   ///< Delete a character at the current cursor position
-};
+const std::string EMPTY_STRING("");
 
-struct ModifyEvent
+float ConvertToEven( float value )
 {
-  ModifyType type;
-  std::string text;
-};
-
-const std::string EMPTY_STRING("");
+  int intValue(static_cast<int>( value ));
+  return static_cast<float>(intValue % 2 == 0) ? intValue : (intValue + 1);
+}
 
 } // namespace
 
@@ -71,1135 +65,367 @@ namespace Toolkit
 namespace Text
 {
 
-struct Controller::FontDefaults
+ControllerPtr Controller::New( ControlInterface& controlInterface )
 {
-  FontDefaults()
-  : mDefaultPointSize(0.0f),
-    mFontId(0u)
-  {
-  }
+  return ControllerPtr( new Controller( controlInterface ) );
+}
 
-  FontId GetFontId( TextAbstraction::FontClient& fontClient )
+void Controller::EnableTextInput( DecoratorPtr decorator )
+{
+  if( !mImpl->mEventData )
   {
-    if( !mFontId )
-    {
-      Dali::TextAbstraction::PointSize26Dot6 pointSize = mDefaultPointSize*64;
-      mFontId = fontClient.GetFontId( mDefaultFontFamily, mDefaultFontStyle, pointSize );
-    }
-
-    return mFontId;
+    mImpl->mEventData = new EventData( decorator );
   }
+}
 
-  std::string mDefaultFontFamily;
-  std::string mDefaultFontStyle;
-  float mDefaultPointSize;
-  FontId mFontId;
-};
-
-struct Controller::TextInput
+void Controller::SetText( const std::string& text )
 {
-  // Used to queue input events until DoRelayout()
-  enum EventType
-  {
-    KEYBOARD_FOCUS_GAIN_EVENT,
-    KEYBOARD_FOCUS_LOST_EVENT,
-    CURSOR_KEY_EVENT,
-    TAP_EVENT,
-    PAN_EVENT,
-    GRAB_HANDLE_EVENT
-  };
+  // Remove the previously set text
+  ResetText();
 
-  union Param
-  {
-    int mInt;
-    unsigned int mUint;
-    float mFloat;
-  };
+  CharacterIndex lastCursorIndex = 0u;
 
-  struct Event
+  if( mImpl->mEventData )
   {
-    Event( EventType eventType )
-    : type( eventType )
+    // If popup shown then hide it by switching to Editing state
+    if ( EventData::SELECTING == mImpl->mEventData->mState ||
+         EventData::SELECTION_CHANGED == mImpl->mEventData->mState ||
+         EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState )
     {
-      p1.mInt = 0;
-      p2.mInt = 0;
+      mImpl->ChangeState( EventData::EDITING );
     }
+  }
 
-    EventType type;
-    Param p1;
-    Param p2;
-    Param p3;
-  };
-
-  struct CursorInfo
-  {
-    CursorInfo()
-    : primaryPosition(),
-      secondaryPosition(),
-      lineHeight( 0.f ),
-      primaryCursorHeight( 0.f ),
-      secondaryCursorHeight( 0.f ),
-      isSecondaryCursor( false )
-    {}
-
-    ~CursorInfo()
-    {}
-
-    Vector2 primaryPosition;       ///< The primary cursor's position.
-    Vector2 secondaryPosition;     ///< The secondary cursor's position.
-    float   lineHeight;            ///< The height of the line where the cursor is placed.
-    float   primaryCursorHeight;   ///< The primary cursor's height.
-    float   secondaryCursorHeight; ///< The secondary cursor's height.
-    bool    isSecondaryCursor;     ///< Whether the secondary cursor is valid.
-  };
-
-  /**
-   * @brief Some characters can be shaped in more than one glyph.
-   * This struct is used to retrieve metrics from these group of glyphs.
-   */
-  struct GlyphMetrics
-  {
-    GlyphMetrics()
-    : fontHeight( 0.f ),
-      advance( 0.f ),
-      ascender( 0.f ),
-      xBearing( 0.f )
-    {}
-
-    ~GlyphMetrics()
-    {}
-
-    float fontHeight; ///< The font's height of that glyphs.
-    float advance;    ///< The sum of all the advances of all the glyphs.
-    float ascender;   ///< The font's ascender.
-    float xBearing;   ///< The x bearing of the first glyph.
-  };
-
-  enum State
-  {
-    INACTIVE,
-    SELECTING,
-    EDITING,
-    EDITING_WITH_POPUP
-  };
-
-  TextInput( LogicalModelPtr logicalModel,
-             VisualModelPtr visualModel,
-             DecoratorPtr decorator,
-             FontDefaults* fontDefaults,
-             TextAbstraction::FontClient& fontClient )
-  : mLogicalModel( logicalModel ),
-    mVisualModel( visualModel ),
-    mDecorator( decorator ),
-    mFontDefaults( fontDefaults ),
-    mFontClient( fontClient ),
-    mState( INACTIVE ),
-    mPrimaryCursorPosition( 0u ),
-    mSecondaryCursorPosition( 0u ),
-    mDecoratorUpdated( false ),
-    mCursorBlinkEnabled( true ),
-    mGrabHandleEnabled( true ),
-    mGrabHandlePopupEnabled( true ),
-    mSelectionEnabled( true ),
-    mHorizontalScrollingEnabled( true ),
-    mVerticalScrollingEnabled( false ),
-    mUpdateCursorPosition( false )
-  {}
-
-  /**
-   * @brief Helper to move the cursor, grab handle etc.
-   */
-  bool ProcessInputEvents( const Vector2& controlSize,
-                           const Vector2& alignmentOffset )
-  {
-    mDecoratorUpdated = false;
-
-    if( mDecorator )
-    {
-      for( vector<TextInput::Event>::iterator iter = mEventQueue.begin(); iter != mEventQueue.end(); ++iter )
-      {
-        switch( iter->type )
-        {
-          case KEYBOARD_FOCUS_GAIN_EVENT:
-          {
-            OnKeyboardFocus( true );
-            break;
-          }
-          case KEYBOARD_FOCUS_LOST_EVENT:
-          {
-            OnKeyboardFocus( false );
-            break;
-          }
-          case CURSOR_KEY_EVENT:
-          {
-            OnCursorKeyEvent( *iter );
-            break;
-          }
-          case TAP_EVENT:
-          {
-            OnTapEvent( *iter, alignmentOffset );
-            break;
-          }
-          case PAN_EVENT:
-          {
-            OnPanEvent( *iter, controlSize, alignmentOffset );
-            break;
-          }
-          case GRAB_HANDLE_EVENT:
-          {
-            OnGrabHandleEvent( *iter );
-            break;
-          }
-        }
-      }
-    }
+  if( !text.empty() )
+  {
+    //  Convert text into UTF-32
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
+    utf32Characters.Resize( text.size() );
 
-    // The cursor must also be repositioned after inserts into the model
-    if( mUpdateCursorPosition )
-    {
-      UpdateCursorPosition();
-      mUpdateCursorPosition = false;
-    }
+    // This is a bit horrible but std::string returns a (signed) char*
+    const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 
-    mEventQueue.clear();
+    // Transform a text array encoded in utf8 into an array encoded in utf32.
+    // It returns the actual number of characters.
+    Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
+    utf32Characters.Resize( characterCount );
 
-    return mDecoratorUpdated;
-  }
+    DALI_ASSERT_DEBUG( text.size() >= characterCount && "Invalid UTF32 conversion length" );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText %p UTF8 size %d, UTF32 size %d\n", this, text.size(), mImpl->mLogicalModel->mText.Count() );
 
-  void OnKeyboardFocus( bool hasFocus )
-  {
-    if( !hasFocus )
-    {
-      ChangeState( INACTIVE );
-    }
-    else
-    {
-      ChangeState( EDITING );
-    }
-  }
+    // To reset the cursor position
+    lastCursorIndex = characterCount;
 
-  void OnCursorKeyEvent( const Event& event )
-  {
-    int keyCode = event.p1.mInt;
+    // Update the rest of the model during size negotiation
+    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
 
-    if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
-    {
-      if( mPrimaryCursorPosition > 0u )
-      {
-        mPrimaryCursorPosition = CalculateNewCursorIndex( mPrimaryCursorPosition - 1u );
-      }
-    }
-    else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
-    {
-      if( mLogicalModel->GetNumberOfCharacters() > mPrimaryCursorPosition )
-      {
-        mPrimaryCursorPosition = CalculateNewCursorIndex( mPrimaryCursorPosition );
-      }
-    }
-    else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
-    {
-      // TODO
-    }
-    else if(   Dali::DALI_KEY_CURSOR_DOWN == keyCode )
-    {
-      // TODO
-    }
+    // The natural size needs to be re-calculated.
+    mImpl->mRecalculateNaturalSize = true;
 
-    UpdateCursorPosition();
+    // Apply modifications to the model
+    mImpl->mOperationsPending = ALL_OPERATIONS;
   }
-
-  void HandleCursorKey( int keyCode )
+  else
   {
-    // TODO
+    ShowPlaceholderText();
   }
 
-  void OnTapEvent( const Event& event,
-                   const Vector2& alignmentOffset  )
-  {
-    unsigned int tapCount = event.p1.mUint;
+  // Resets the cursor position.
+  ResetCursorPosition( lastCursorIndex );
 
-    if( 1u == tapCount )
-    {
-      ChangeState( EDITING );
+  // Scrolls the text to make the cursor visible.
+  ResetScrollPosition();
 
-      float xPosition = event.p2.mFloat - alignmentOffset.x;
-      float yPosition = event.p3.mFloat - alignmentOffset.y;
+  mImpl->RequestRelayout();
 
-      mPrimaryCursorPosition = GetClosestCursorIndex( xPosition,
-                                                      yPosition );
+  if( mImpl->mEventData )
+  {
+    // Cancel previously queued events
+    mImpl->mEventData->mEventQueue.clear();
+  }
 
-      UpdateCursorPosition();
-    }
-    else if( mSelectionEnabled &&
-             2u == tapCount )
-    {
-      ChangeState( SELECTING );
+  // Reset keyboard as text changed
+  mImpl->ResetImfManager();
 
-      RepositionSelectionHandles( event.p2.mFloat, event.p3.mFloat );
-    }
- }
+  // Do this last since it provides callbacks into application code
+  mImpl->mControlInterface.TextChanged();
+}
 
-  void OnPanEvent( const Event& event,
-                   const Vector2& controlSize,
-                   const Vector2& alignmentOffset )
+void Controller::GetText( std::string& text ) const
+{
+  if( ! mImpl->IsShowingPlaceholderText() )
   {
-    int state = event.p1.mInt;
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 
-    if( Gesture::Started    == state ||
-        Gesture::Continuing == state )
+    if( 0u != utf32Characters.Count() )
     {
-      const Vector2& actualSize = mVisualModel->GetActualSize();
-
-      if( mHorizontalScrollingEnabled )
-      {
-        const float displacementX = event.p2.mFloat;
-        mScrollPosition.x += displacementX;
-
-        // Clamp between -space & 0 (and the text alignment).
-        const float contentWidth = actualSize.width;
-        if( contentWidth > controlSize.width )
-        {
-          const float space = ( contentWidth - controlSize.width ) + alignmentOffset.x;
-          mScrollPosition.x = ( mScrollPosition.x < -space ) ? -space : mScrollPosition.x;
-          mScrollPosition.x = ( mScrollPosition.x > -alignmentOffset.x ) ? -alignmentOffset.x : mScrollPosition.x;
-
-          mDecoratorUpdated = true;
-        }
-        else
-        {
-          mScrollPosition.x = 0.f;
-        }
-      }
-
-      if( mVerticalScrollingEnabled )
-      {
-        const float displacementY = event.p3.mFloat;
-        mScrollPosition.y += displacementY;
-
-        // Clamp between -space & 0 (and the text alignment).
-        if( actualSize.height > controlSize.height )
-        {
-          const float space = ( actualSize.height - controlSize.height ) + alignmentOffset.y;
-          mScrollPosition.y = ( mScrollPosition.y < -space ) ? -space : mScrollPosition.y;
-          mScrollPosition.y = ( mScrollPosition.y > -alignmentOffset.y ) ? -alignmentOffset.y : mScrollPosition.y;
-
-          mDecoratorUpdated = true;
-        }
-        else
-        {
-          mScrollPosition.y = 0.f;
-        }
-      }
+      Utf32ToUtf8( &utf32Characters[0], utf32Characters.Count(), text );
     }
   }
-
-  void OnGrabHandleEvent( const Event& event )
+  else
   {
-    unsigned int state = event.p1.mUint;
-
-    if( GRAB_HANDLE_PRESSED == state )
-    {
-      float xPosition = event.p2.mFloat + mScrollPosition.x;
-      float yPosition = event.p3.mFloat + mScrollPosition.y;
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
+  }
+}
 
-      mPrimaryCursorPosition = GetClosestCursorIndex( xPosition,
-                                                      yPosition );
+unsigned int Controller::GetLogicalCursorPosition() const
+{
+  if( mImpl->mEventData )
+  {
+    return mImpl->mEventData->mPrimaryCursorPosition;
+  }
 
-      UpdateCursorPosition();
+  return 0u;
+}
 
-      //mDecorator->HidePopup();
-      ChangeState ( EDITING );
+void Controller::SetPlaceholderText( PlaceholderType type, const std::string& text )
+{
+  if( mImpl->mEventData )
+  {
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
+    {
+      mImpl->mEventData->mPlaceholderTextInactive = text;
     }
-    else if ( mGrabHandlePopupEnabled &&
-              GRAB_HANDLE_RELEASED == state )
+    else
     {
-      //mDecorator->ShowPopup();
-      ChangeState ( EDITING_WITH_POPUP );
-      mDecoratorUpdated = true;
+      mImpl->mEventData->mPlaceholderTextActive = text;
     }
-  }
-
-  void RepositionSelectionHandles( float visualX, float visualY )
-  {
-    // TODO - Find which word was selected
-
-    const Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
-    const Vector<Vector2>::SizeType glyphCount = glyphs.Count();
 
-    const Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
-    const Vector<Vector2>::SizeType positionCount = positions.Count();
-
-    // Guard against glyphs which did not fit inside the layout
-    const Vector<Vector2>::SizeType count = (positionCount < glyphCount) ? positionCount : glyphCount;
-
-    if( count )
+    // Update placeholder if there is no text
+    if( mImpl->IsShowingPlaceholderText() ||
+        0u == mImpl->mLogicalModel->mText.Count() )
     {
-      float primaryX   = positions[0].x;
-      float secondaryX = positions[count-1].x + glyphs[count-1].width;
-
-      // TODO - multi-line selection
-      const Vector<LineRun>& lines = mVisualModel->mLines;
-      float height = lines.Count() ? lines[0].ascender + -lines[0].descender : 0.0f;
-
-      mDecorator->SetPosition( PRIMARY_SELECTION_HANDLE,   primaryX,   0.0f, height );
-      mDecorator->SetPosition( SECONDARY_SELECTION_HANDLE, secondaryX, 0.0f, height );
-
-      mDecorator->ClearHighlights();
-      mDecorator->AddHighlight( primaryX, 0.0f, secondaryX, height );
+      ShowPlaceholderText();
     }
   }
+}
 
-  void ChangeState( State newState )
+void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
+{
+  if( mImpl->mEventData )
   {
-    if( mState != newState )
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
     {
-      mState = newState;
-
-      if( INACTIVE == mState )
-      {
-        mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-        mDecorator->StopCursorBlink();
-        mDecorator->SetGrabHandleActive( false );
-        mDecorator->SetSelectionActive( false );
-        mDecorator->SetPopupActive( false );
-        mDecoratorUpdated = true;
-      }
-      else if ( SELECTING == mState )
-      {
-        mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-        mDecorator->StopCursorBlink();
-        mDecorator->SetGrabHandleActive( false );
-        mDecorator->SetSelectionActive( true );
-        mDecoratorUpdated = true;
-      }
-      else if( EDITING == mState )
-      {
-        mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-        if( mCursorBlinkEnabled )
-        {
-          mDecorator->StartCursorBlink();
-        }
-        if( mGrabHandleEnabled )
-        {
-          mDecorator->SetGrabHandleActive( true );
-        }
-        if( mGrabHandlePopupEnabled )
-        {
-          mDecorator->SetPopupActive( false );
-        }
-        mDecorator->SetSelectionActive( false );
-        mDecoratorUpdated = true;
-      }
-      else if( EDITING_WITH_POPUP == mState )
-      {
-        mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-        if( mCursorBlinkEnabled )
-        {
-          mDecorator->StartCursorBlink();
-        }
-        if( mGrabHandleEnabled )
-        {
-          mDecorator->SetGrabHandleActive( true );
-        }
-        if( mGrabHandlePopupEnabled )
-        {
-          mDecorator->SetPopupActive( true );
-        }
-        mDecorator->SetSelectionActive( false );
-        mDecoratorUpdated = true;
-      }
+      text = mImpl->mEventData->mPlaceholderTextInactive;
     }
-  }
-
-  LineIndex 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 )
+    else
     {
-      const LineRun& lineRun = lines[lineIndex];
-      totalHeight += lineRun.ascender + -lineRun.descender;
-      if( y < totalHeight )
-      {
-        return lineIndex;
-      }
+      text = mImpl->mEventData->mPlaceholderTextActive;
     }
-
-    return lineIndex-1;
   }
+}
 
-  /**
-   * @brief Retrieves the cursor's logical position for a given touch point x,y
-   *
-   * @param[in] visualX The touch point x.
-   * @param[in] visualY The touch point y.
-   *
-   * @return The logical cursor position (in characters). 0 is just before the first character, a value equal to the number of characters is just after the last character.
-   */
-  CharacterIndex GetClosestCursorIndex( float visualX,
-                                        float visualY ) const
+void Controller::SetMaximumNumberOfCharacters( int maxCharacters )
+{
+  if ( maxCharacters >= 0 )
   {
-    CharacterIndex logicalIndex = 0u;
+    mImpl->mMaximumNumberOfCharacters = maxCharacters;
+  }
+}
 
-    const Length numberOfGlyphs = mVisualModel->mGlyphs.Count();
-    const Length numberOfLines  = mVisualModel->mLines.Count();
-    if( 0 == numberOfGlyphs ||
-        0 == numberOfLines )
-    {
-      return logicalIndex;
-    }
+int Controller::GetMaximumNumberOfCharacters()
+{
+  return mImpl->mMaximumNumberOfCharacters;
+}
 
-    // Transform to visual model coords
-    visualX -= mScrollPosition.x;
-    visualY -= mScrollPosition.y;
+void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
+{
+  if( !mImpl->mFontDefaults )
+  {
+    mImpl->mFontDefaults = new FontDefaults();
+  }
+
+  mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
 
-    // Find which line is closest
-    const LineIndex lineIndex = GetClosestLine( visualY );
-    const LineRun& line = mVisualModel->mLines[lineIndex];
+  // Clear the font-specific data
+  ClearFontData();
 
-    // Get the positions of the glyphs.
-    const Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
-    const Vector2* const positionsBuffer = positions.Begin();
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
 
-    // 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();
+  mImpl->RequestRelayout();
+}
 
-    // Get the character to glyph conversion table.
-    const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
+const std::string& Controller::GetDefaultFontFamily() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultFontFamily;
+  }
 
-    // Get the glyphs per character table.
-    const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
+  return EMPTY_STRING;
+}
 
-    // If the vector is void, there is no right to left characters.
-    const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer;
+void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
+{
+  if( !mImpl->mFontDefaults )
+  {
+    mImpl->mFontDefaults = new FontDefaults();
+  }
 
-    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" );
+  mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
 
-    // Whether there is a hit on a glyph.
-    bool matched = false;
+  // Clear the font-specific data
+  ClearFontData();
 
-    // Traverses glyphs in visual order. To do that use the visual to logical conversion table.
-    CharacterIndex visualIndex = startCharacter;
-    for( ; !matched && ( visualIndex < endCharacter ); ++visualIndex )
-    {
-      // The character in logical order.
-      const CharacterIndex characterLogicalOrderIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + visualIndex ) : visualIndex;
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
 
-      // The first glyph for that character in logical order.
-      const GlyphIndex glyphLogicalOrderIndex = *( charactersToGlyphBuffer + characterLogicalOrderIndex );
+  mImpl->RequestRelayout();
+}
 
-      // The number of glyphs for that character
-      const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + characterLogicalOrderIndex );
+const std::string& Controller::GetDefaultFontStyle() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultFontStyle;
+  }
 
-      // Get the metrics for the group of glyphs.
-      GlyphMetrics glyphMetrics;
-      GetGlyphsMetrics( glyphLogicalOrderIndex,
-                        numberOfGlyphs,
-                        glyphMetrics );
+  return EMPTY_STRING;
+}
 
-      const Vector2& position = *( positionsBuffer + glyphLogicalOrderIndex );
+void Controller::SetDefaultPointSize( float pointSize )
+{
+  if( !mImpl->mFontDefaults )
+  {
+    mImpl->mFontDefaults = new FontDefaults();
+  }
 
-      const float glyphX = -glyphMetrics.xBearing + position.x + 0.5f * glyphMetrics.advance;
+  mImpl->mFontDefaults->mDefaultPointSize = pointSize;
 
-      if( visualX < glyphX )
-      {
-        matched = true;
-        break;
-      }
-    }
+  // Clear the font-specific data
+  ClearFontData();
 
-    // Return the logical position of the cursor in characters.
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
 
-    if( !matched )
-    {
-      visualIndex = endCharacter;
-    }
+  mImpl->RequestRelayout();
+}
 
-    return hasRightToLeftCharacters ? *( visualToLogicalCursorBuffer + visualIndex ) : visualIndex;
+float Controller::GetDefaultPointSize() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultPointSize;
   }
 
-  /**
-   * @brief Calculates the cursor's position for a given character index in the logical order.
-   *
-   * It retrieves as well the line's height and the cursor's height and
-   * if there is a valid alternative cursor, its position and height.
-   *
-   * @param[in] logical The logical cursor position (in characters). 0 is just before the first character, a value equal to the number of characters is just after the last character.
-   * @param[out] cursorInfo The line's height, the cursor's height, the cursor's position and whether there is an alternative cursor.
-   */
-  void GetCursorPosition( CharacterIndex logical,
-                          CursorInfo& cursorInfo ) const
-  {
-    // TODO: Check for multiline with \n, etc...
+  return 0.0f;
+}
 
-    // Check if the logical position is the first or the last one of the text.
-    const bool isFirstPosition = 0u == logical;
-    const bool isLastPosition = mLogicalModel->GetNumberOfCharacters() == logical;
+void Controller::SetTextColor( const Vector4& textColor )
+{
+  mImpl->mTextColor = textColor;
 
-    if( isFirstPosition && isLastPosition )
-    {
-      // There is zero characters. Get the default font.
+  if( !mImpl->IsShowingPlaceholderText() )
+  {
+    mImpl->mVisualModel->SetTextColor( textColor );
 
-      FontId defaultFontId = 0u;
-      if( NULL == mFontDefaults )
-      {
-        defaultFontId = mFontClient.GetFontId( EMPTY_STRING,
-                                               EMPTY_STRING );
-      }
-      else
-      {
-        defaultFontId = mFontDefaults->GetFontId( mFontClient );
-      }
+    mImpl->RequestRelayout();
+  }
+}
 
-      Text::FontMetrics fontMetrics;
-      mFontClient.GetFontMetrics( defaultFontId, fontMetrics );
+const Vector4& Controller::GetTextColor() const
+{
+  return mImpl->mTextColor;
+}
 
-      cursorInfo.lineHeight = fontMetrics.ascender - fontMetrics.descender;
-      cursorInfo.primaryCursorHeight = cursorInfo.lineHeight;
+bool Controller::RemoveText( int cursorOffset, int numberOfChars )
+{
+  bool removed( false );
 
-      cursorInfo.primaryPosition.x = 0.f;
-      cursorInfo.primaryPosition.y = 0.f;
+  DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p mText.Count() %d cursor %d cursorOffset %d numberOfChars %d\n",
+                 this, mImpl->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition, cursorOffset, numberOfChars );
 
-      // Nothing else to do.
-      return;
-    }
+  if( ! mImpl->IsShowingPlaceholderText() )
+  {
+    // Delete at current cursor position
+    Vector<Character>& currentText = mImpl->mLogicalModel->mText;
+    CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
 
-    // Get the previous logical index.
-    const CharacterIndex previousLogical = isFirstPosition ? 0u : logical - 1u;
+    CharacterIndex cursorIndex = oldCursorIndex;
 
-    // Decrease the logical index if it's the last one.
-    if( isLastPosition )
+    // Validate the cursor position & number of characters
+    if( static_cast< CharacterIndex >( std::abs( cursorOffset ) ) <= cursorIndex )
     {
-      --logical;
+      cursorIndex = oldCursorIndex + cursorOffset;
     }
 
-    // Get the direction of the character and the previous one.
-    const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL;
-
-    CharacterDirection isCurrentRightToLeft = false;
-    CharacterDirection isPreviousRightToLeft = false;
-    if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
+    if( (cursorIndex + numberOfChars) > currentText.Count() )
     {
-      isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + logical );
-      isPreviousRightToLeft = *( modelCharacterDirectionsBuffer + previousLogical );
+      numberOfChars = currentText.Count() - cursorIndex;
     }
 
-    // Get the line where the character is laid-out.
-    const LineRun* modelLines = mVisualModel->mLines.Begin();
-
-    const LineIndex lineIndex = mVisualModel->GetLineOfCharacter( logical );
-    const LineRun& line = *( modelLines + lineIndex );
-
-    // Get the paragraph's direction.
-    const CharacterDirection isRightToLeftParagraph = line.direction;
-
-    // Check whether there is an alternative position:
-
-    cursorInfo.isSecondaryCursor = ( isCurrentRightToLeft != isPreviousRightToLeft ) ||
-                                   ( isLastPosition && ( isRightToLeftParagraph != isCurrentRightToLeft ) );
-
-    // Set the line height.
-    cursorInfo.lineHeight = line.ascender + -line.descender;
-
-    // Convert the cursor position into the glyph position.
-    CharacterIndex characterIndex = logical;
-    if( cursorInfo.isSecondaryCursor &&
-        ( isRightToLeftParagraph != isCurrentRightToLeft ) )
+    if( (cursorIndex + numberOfChars) <= currentText.Count() )
     {
-      characterIndex = previousLogical;
-    }
+      Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
+      Vector<Character>::Iterator last  = first + numberOfChars;
 
-    const GlyphIndex currentGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + characterIndex );
-    const Length numberOfGlyphs = *( mVisualModel->mGlyphsPerCharacter.Begin() + characterIndex );
-    const Length numberOfCharacters = *( mVisualModel->mCharactersPerGlyph.Begin() +currentGlyphIndex );
+      currentText.Erase( first, last );
 
-    // Get the metrics for the group of glyphs.
-    GlyphMetrics glyphMetrics;
-    GetGlyphsMetrics( currentGlyphIndex,
-                      numberOfGlyphs,
-                      glyphMetrics );
+      // Cursor position retreat
+      oldCursorIndex = cursorIndex;
 
-    float interGlyphAdvance = 0.f;
-    if( !isLastPosition &&
-        ( numberOfCharacters > 1u ) )
-    {
-      const CharacterIndex firstIndex = *( mVisualModel->mGlyphsToCharacters.Begin() + currentGlyphIndex );
-      interGlyphAdvance = static_cast<float>( characterIndex - firstIndex ) * glyphMetrics.advance / static_cast<float>( numberOfCharacters );
+      DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfChars );
+      removed = true;
     }
+  }
 
-    // Get the glyph position and x bearing.
-    const Vector2& currentPosition = *( mVisualModel->mGlyphPositions.Begin() + currentGlyphIndex );
+  return removed;
+}
 
-    // Set the cursor's height.
-    cursorInfo.primaryCursorHeight = glyphMetrics.fontHeight;
+void Controller::SetPlaceholderTextColor( const Vector4& textColor )
+{
+  if( mImpl->mEventData )
+  {
+    mImpl->mEventData->mPlaceholderTextColor = textColor;
+  }
 
-    // Set the position.
-    cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + currentPosition.x + ( isCurrentRightToLeft ? glyphMetrics.advance : interGlyphAdvance );
-    cursorInfo.primaryPosition.y = line.ascender - glyphMetrics.ascender;
+  if( mImpl->IsShowingPlaceholderText() )
+  {
+    mImpl->mVisualModel->SetTextColor( textColor );
+    mImpl->RequestRelayout();
+  }
+}
 
-    if( isLastPosition )
-    {
-      // The position of the cursor after the last character needs special
-      // care depending on its direction and the direction of the paragraph.
-
-      if( cursorInfo.isSecondaryCursor )
-      {
-        // 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!
-        characterIndex = isRightToLeftParagraph ? line.characterRun.characterIndex : line.characterRun.characterIndex + line.characterRun.numberOfCharacters - 1u;
-        characterIndex = mLogicalModel->GetLogicalCharacterIndex( characterIndex );
-
-        const GlyphIndex glyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + characterIndex );
-        const Length numberOfGlyphs = *( mVisualModel->mGlyphsPerCharacter.Begin() + characterIndex );
-
-        const Vector2& position = *( mVisualModel->mGlyphPositions.Begin() + glyphIndex );
-
-        // Get the metrics for the group of glyphs.
-        GlyphMetrics glyphMetrics;
-        GetGlyphsMetrics( glyphIndex,
-                          numberOfGlyphs,
-                          glyphMetrics );
-
-        cursorInfo.primaryPosition.x = -glyphMetrics.xBearing + position.x + ( isRightToLeftParagraph ? 0.f : glyphMetrics.advance );
-
-        cursorInfo.primaryPosition.y = line.ascender - glyphMetrics.ascender;
-      }
-      else
-      {
-        if( !isCurrentRightToLeft )
-        {
-          cursorInfo.primaryPosition.x += glyphMetrics.advance;
-        }
-        else
-        {
-          cursorInfo.primaryPosition.x -= glyphMetrics.advance;
-        }
-      }
-    }
-
-    // Set the alternative cursor position.
-    if( cursorInfo.isSecondaryCursor )
-    {
-      // Convert the cursor position into the glyph position.
-      const CharacterIndex previousCharacterIndex = ( ( isRightToLeftParagraph != isCurrentRightToLeft ) ? logical : previousLogical );
-      const GlyphIndex previousGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + previousCharacterIndex );
-      const Length numberOfGlyphs = *( mVisualModel->mGlyphsPerCharacter.Begin() + previousCharacterIndex );
-
-      // Get the glyph position.
-      const Vector2& previousPosition = *( mVisualModel->mGlyphPositions.Begin() + previousGlyphIndex );
-
-      // Get the metrics for the group of glyphs.
-      GlyphMetrics glyphMetrics;
-      GetGlyphsMetrics( previousGlyphIndex,
-                        numberOfGlyphs,
-                        glyphMetrics );
-
-      // Set the cursor position and height.
-      cursorInfo.secondaryPosition.x = -glyphMetrics.xBearing + previousPosition.x + ( ( ( isLastPosition && !isCurrentRightToLeft ) ||
-                                                                                         ( !isLastPosition && isCurrentRightToLeft )    ) ? glyphMetrics.advance : 0.f );
-
-      cursorInfo.secondaryCursorHeight = 0.5f * glyphMetrics.fontHeight;
-
-      cursorInfo.secondaryPosition.y = cursorInfo.lineHeight - cursorInfo.secondaryCursorHeight - line.descender - ( glyphMetrics.fontHeight - glyphMetrics.ascender );
-
-      // Update the primary cursor height as well.
-      cursorInfo.primaryCursorHeight *= 0.5f;
-    }
-  }
-
-  /**
-   * @brief Get some glyph's metrics of a group of glyphs formed as a result of shaping one character.
-   *
-   * @param[in] glyphIndex The index to the first glyph.
-   * @param[in] numberOfGlyphs The number of glyphs.
-   * @param[out] glyphMetrics Some glyph metrics (font height, advance, ascender and x bearing).
-   */
-  void GetGlyphsMetrics( GlyphIndex glyphIndex,
-                         Length numberOfGlyphs,
-                         GlyphMetrics& glyphMetrics ) const
-  {
-    const GlyphInfo* glyphsBuffer = mVisualModel->mGlyphs.Begin();
-
-    const GlyphInfo& firstGlyph = *( glyphsBuffer + glyphIndex );
-
-    Text::FontMetrics fontMetrics;
-    mFontClient.GetFontMetrics( firstGlyph.fontId, fontMetrics );
-
-    glyphMetrics.fontHeight = fontMetrics.height;
-    glyphMetrics.advance = firstGlyph.advance;
-    glyphMetrics.ascender = fontMetrics.ascender;
-    glyphMetrics.xBearing = firstGlyph.xBearing;
-
-    for( unsigned int i = 1u; i < numberOfGlyphs; ++i )
-    {
-      const GlyphInfo& glyphInfo = *( glyphsBuffer + glyphIndex + i );
-
-      glyphMetrics.advance += glyphInfo.advance;
-    }
-  }
-
-  /**
-   * @brief Calculates the new cursor index.
-   *
-   * It takes into account that in some scripts multiple characters can form a glyph and all of them
-   * need to be jumped with one key event.
-   *
-   * @param[in] index The initial new index.
-   *
-   * @return The new cursor index.
-   */
-  CharacterIndex CalculateNewCursorIndex( CharacterIndex index ) const
-  {
-    CharacterIndex cursorIndex = mPrimaryCursorPosition;
-
-    const Script script = mLogicalModel->GetScript( index );
-    const GlyphIndex* charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
-    const Length* charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
-
-    Length numberOfCharacters = 0u;
-    if( TextAbstraction::LATIN == script )
-    {
-      // Prevents to jump the whole Latin ligatures like fi, ff, ...
-      numberOfCharacters = 1u;
-    }
-    else
-    {
-      GlyphIndex glyphIndex = *( charactersToGlyphBuffer + index );
-      numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex );
-
-      while( 0u == numberOfCharacters )
-      {
-        numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex );
-        ++glyphIndex;
-      }
-    }
-
-    if( index < mPrimaryCursorPosition )
-    {
-      cursorIndex -= numberOfCharacters;
-    }
-    else
-    {
-      cursorIndex += numberOfCharacters;
-    }
-
-    return cursorIndex;
-  }
-
-  void UpdateCursorPosition()
-  {
-    CursorInfo cursorInfo;
-
-    GetCursorPosition( mPrimaryCursorPosition,
-                       cursorInfo );
-
-    mDecorator->SetPosition( PRIMARY_CURSOR,
-                             cursorInfo.primaryPosition.x,
-                             cursorInfo.primaryPosition.y,
-                             cursorInfo.primaryCursorHeight,
-                             cursorInfo.lineHeight );
-
-    if( cursorInfo.isSecondaryCursor )
-    {
-      mDecorator->SetActiveCursor( ACTIVE_CURSOR_BOTH );
-      mDecorator->SetPosition( SECONDARY_CURSOR,
-                               cursorInfo.secondaryPosition.x,
-                               cursorInfo.secondaryPosition.y,
-                               cursorInfo.secondaryCursorHeight,
-                               cursorInfo.lineHeight );
-    }
-    else
-    {
-      mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-    }
-
-    mUpdateCursorPosition = false;
-    mDecoratorUpdated = true;
-  }
-
-  LogicalModelPtr              mLogicalModel;
-  VisualModelPtr               mVisualModel;
-  DecoratorPtr                 mDecorator;
-  FontDefaults*                mFontDefaults;
-  TextAbstraction::FontClient& mFontClient;
-  std::string                  mPlaceholderText;
-
-  /**
-   * This is used to delay handling events until after the model has been updated.
-   * The number of updates to the model is minimized to improve performance.
-   */
-  vector<Event> mEventQueue; ///< The queue of touch events etc.
-
-  State mState; ///< Selection mode, edit mode etc.
-
-  CharacterIndex mPrimaryCursorPosition;   ///< Index into logical model for primary cursor
-  CharacterIndex mSecondaryCursorPosition; ///< Index into logical model for secondary cursor
-
-  /**
-   * 0,0 means that the top-left corner of the layout matches the top-left corner of the UI control.
-   * Typically this will have a negative value with scrolling occurs.
-   */
-  Vector2 mScrollPosition; ///< The text is offset by this position when scrolling.
-
-  bool mDecoratorUpdated           : 1; ///< True if the decorator was updated during event processing
-  bool mCursorBlinkEnabled         : 1; ///< True if cursor should blink when active
-  bool mGrabHandleEnabled          : 1; ///< True if grab handle is enabled
-  bool mGrabHandlePopupEnabled     : 1; ///< True if the grab handle popu-up should be shown
-  bool mSelectionEnabled           : 1; ///< True if selection handles, highlight etc. are enabled
-  bool mHorizontalScrollingEnabled : 1; ///< True if horizontal scrolling is enabled
-  bool mVerticalScrollingEnabled   : 1; ///< True if vertical scrolling is enabled
-  bool mUpdateCursorPosition       : 1; ///< True if the visual position of the cursor must be recalculated
-};
-
-struct Controller::Impl
-{
-  Impl( ControlInterface& controlInterface )
-  : mControlInterface( controlInterface ),
-    mLogicalModel(),
-    mVisualModel(),
-    mFontDefaults( NULL ),
-    mTextInput( NULL ),
-    mFontClient(),
-    mView(),
-    mLayoutEngine(),
-    mModifyEvents(),
-    mControlSize(),
-    mAlignmentOffset(),
-    mOperationsPending( NO_OPERATION ),
-    mRecalculateNaturalSize( true )
-  {
-    mLogicalModel = LogicalModel::New();
-    mVisualModel  = VisualModel::New();
-
-    mFontClient = TextAbstraction::FontClient::Get();
-
-    mView.SetVisualModel( mVisualModel );
-
-    // Set the text properties to default
-    mVisualModel->SetTextColor( Color::WHITE );
-    mVisualModel->SetShadowOffset( Vector2::ZERO );
-    mVisualModel->SetShadowColor( Vector4::ZERO );
-    mVisualModel->SetUnderlineEnabled( false );
-  }
-
-  ~Impl()
-  {
-    delete mTextInput;
-  }
-
-  ControlInterface& mControlInterface;     ///< Reference to the text controller.
-  LogicalModelPtr mLogicalModel;           ///< Pointer to the logical model.
-  VisualModelPtr  mVisualModel;            ///< Pointer to the visual model.
-  FontDefaults* mFontDefaults;             ///< Avoid allocating this when the user does not specify a font.
-  Controller::TextInput* mTextInput;       ///< Avoid allocating everything for text input until EnableTextInput().
-  TextAbstraction::FontClient mFontClient; ///< Handle to the font client.
-  View mView;                              ///< The view interface to the rendering back-end.
-  LayoutEngine mLayoutEngine;              ///< The layout engine.
-  std::vector<ModifyEvent> mModifyEvents;  ///< Temporary stores the text set until the next relayout.
-  Size mControlSize;                       ///< The size of the control.
-  Vector2 mAlignmentOffset;                ///< Vertical and horizontal offset of the whole text inside the control due to alignment.
-  OperationsMask mOperationsPending;       ///< Operations pending to be done to layout the text.
-  bool mRecalculateNaturalSize:1;          ///< Whether the natural size needs to be recalculated.
-};
-
-ControllerPtr Controller::New( ControlInterface& controlInterface )
-{
-  return ControllerPtr( new Controller( controlInterface ) );
-}
-
-void Controller::SetText( const std::string& text )
-{
-  // Cancel previously queued inserts etc.
-  mImpl->mModifyEvents.clear();
-
-  // Keep until size negotiation
-  ModifyEvent event;
-  event.type = REPLACE_TEXT;
-  event.text = text;
-  mImpl->mModifyEvents.push_back( event );
-
-  if( mImpl->mTextInput )
-  {
-    // Cancel previously queued events
-    mImpl->mTextInput->mEventQueue.clear();
-
-    // TODO - Hide selection decorations
-  }
-}
-
-void Controller::GetText( std::string& text ) const
-{
-  if( !mImpl->mModifyEvents.empty() &&
-       REPLACE_TEXT == mImpl->mModifyEvents[0].type )
-  {
-    text = mImpl->mModifyEvents[0].text;
-  }
-  else
-  {
-    // TODO - Convert from UTF-32
-  }
-}
-
-void Controller::SetPlaceholderText( const std::string& text )
-{
-  if( !mImpl->mTextInput )
-  {
-    mImpl->mTextInput->mPlaceholderText = text;
-  }
-}
-
-void Controller::GetPlaceholderText( std::string& text ) const
-{
-  if( !mImpl->mTextInput )
-  {
-    text = mImpl->mTextInput->mPlaceholderText;
-  }
-}
-
-void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
-{
-  if( !mImpl->mFontDefaults )
-  {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
-  }
-
-  mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
-  mImpl->mOperationsPending = ALL_OPERATIONS;
-  mImpl->mRecalculateNaturalSize = true;
-
-  // Clear the font-specific data
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
-
-  RequestRelayout();
-}
-
-const std::string& Controller::GetDefaultFontFamily() const
-{
-  if( mImpl->mFontDefaults )
-  {
-    return mImpl->mFontDefaults->mDefaultFontFamily;
-  }
-
-  return EMPTY_STRING;
-}
-
-void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
-{
-  if( !mImpl->mFontDefaults )
-  {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
-  }
-
-  mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
-  mImpl->mOperationsPending = ALL_OPERATIONS;
-  mImpl->mRecalculateNaturalSize = true;
-
-  // Clear the font-specific data
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
-
-  RequestRelayout();
-}
-
-const std::string& Controller::GetDefaultFontStyle() const
+const Vector4& Controller::GetPlaceholderTextColor() const
 {
-  if( mImpl->mFontDefaults )
+  if( mImpl->mEventData )
   {
-    return mImpl->mFontDefaults->mDefaultFontStyle;
+    return mImpl->mEventData->mPlaceholderTextColor;
   }
 
-  return EMPTY_STRING;
+  return Color::BLACK;
 }
 
-void Controller::SetDefaultPointSize( float pointSize )
+void Controller::SetShadowOffset( const Vector2& shadowOffset )
 {
-  if( !mImpl->mFontDefaults )
-  {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
-  }
-
-  mImpl->mFontDefaults->mDefaultPointSize = pointSize;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
-  mImpl->mOperationsPending = ALL_OPERATIONS;
-  mImpl->mRecalculateNaturalSize = true;
-
-  // Clear the font-specific data
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
+  mImpl->mVisualModel->SetShadowOffset( shadowOffset );
 
-  RequestRelayout();
+  mImpl->RequestRelayout();
 }
 
-float Controller::GetDefaultPointSize() const
+const Vector2& Controller::GetShadowOffset() const
 {
-  if( mImpl->mFontDefaults )
-  {
-    return mImpl->mFontDefaults->mDefaultPointSize;
-  }
-
-  return 0.0f;
+  return mImpl->mVisualModel->GetShadowOffset();
 }
 
-void Controller::GetDefaultFonts( Vector<FontRun>& fonts, Length numberOfCharacters ) const
+void Controller::SetShadowColor( const Vector4& shadowColor )
 {
-  if( mImpl->mFontDefaults )
-  {
-    FontRun fontRun;
-    fontRun.characterRun.characterIndex = 0;
-    fontRun.characterRun.numberOfCharacters = numberOfCharacters;
-    fontRun.fontId = mImpl->mFontDefaults->GetFontId( mImpl->mFontClient );
-    fontRun.isDefault = true;
+  mImpl->mVisualModel->SetShadowColor( shadowColor );
 
-    fonts.PushBack( fontRun );
-  }
+  mImpl->RequestRelayout();
 }
 
-const Vector4& Controller::GetTextColor() const
+const Vector4& Controller::GetShadowColor() const
 {
-  return mImpl->mVisualModel->GetTextColor();
+  return mImpl->mVisualModel->GetShadowColor();
 }
 
-const Vector2& Controller::GetShadowOffset() const
+void Controller::SetUnderlineColor( const Vector4& color )
 {
-  return mImpl->mVisualModel->GetShadowOffset();
-}
+  mImpl->mVisualModel->SetUnderlineColor( color );
 
-const Vector4& Controller::GetShadowColor() const
-{
-  return mImpl->mVisualModel->GetShadowColor();
+  mImpl->RequestRelayout();
 }
 
 const Vector4& Controller::GetUnderlineColor() const
@@ -1207,69 +433,51 @@ const Vector4& Controller::GetUnderlineColor() const
   return mImpl->mVisualModel->GetUnderlineColor();
 }
 
-bool Controller::IsUnderlineEnabled() const
-{
-  return mImpl->mVisualModel->IsUnderlineEnabled();
-}
-
-void Controller::SetTextColor( const Vector4& textColor )
+void Controller::SetUnderlineEnabled( bool enabled )
 {
-  mImpl->mVisualModel->SetTextColor( textColor );
-}
+  mImpl->mVisualModel->SetUnderlineEnabled( enabled );
 
-void Controller::SetShadowOffset( const Vector2& shadowOffset )
-{
-  mImpl->mVisualModel->SetShadowOffset( shadowOffset );
+  mImpl->RequestRelayout();
 }
 
-void Controller::SetShadowColor( const Vector4& shadowColor )
+bool Controller::IsUnderlineEnabled() const
 {
-  mImpl->mVisualModel->SetShadowColor( shadowColor );
+  return mImpl->mVisualModel->IsUnderlineEnabled();
 }
 
-void Controller::SetUnderlineColor( const Vector4& color )
+void Controller::SetUnderlineHeight( float height )
 {
-  mImpl->mVisualModel->SetUnderlineColor( color );
-}
+  mImpl->mVisualModel->SetUnderlineHeight( height );
 
-void Controller::SetUnderlineEnabled( bool enabled )
-{
-  mImpl->mVisualModel->SetUnderlineEnabled( enabled );
+  mImpl->RequestRelayout();
 }
 
-void Controller::EnableTextInput( DecoratorPtr decorator )
+float Controller::GetUnderlineHeight() const
 {
-  if( !mImpl->mTextInput )
-  {
-    mImpl->mTextInput = new TextInput( mImpl->mLogicalModel,
-                                       mImpl->mVisualModel,
-                                       decorator,
-                                       mImpl->mFontDefaults,
-                                       mImpl->mFontClient );
-  }
+  return mImpl->mVisualModel->GetUnderlineHeight();
 }
 
 void Controller::SetEnableCursorBlink( bool enable )
 {
-  DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "TextInput disabled" );
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "TextInput disabled" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    mImpl->mTextInput->mCursorBlinkEnabled = enable;
+    mImpl->mEventData->mCursorBlinkEnabled = enable;
 
     if( !enable &&
-        mImpl->mTextInput->mDecorator )
+        mImpl->mEventData->mDecorator )
     {
-      mImpl->mTextInput->mDecorator->StopCursorBlink();
+      mImpl->mEventData->mDecorator->StopCursorBlink();
     }
   }
 }
 
 bool Controller::GetEnableCursorBlink() const
 {
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    return mImpl->mTextInput->mCursorBlinkEnabled;
+    return mImpl->mEventData->mCursorBlinkEnabled;
   }
 
   return false;
@@ -1277,9 +485,9 @@ bool Controller::GetEnableCursorBlink() const
 
 const Vector2& Controller::GetScrollPosition() const
 {
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    return mImpl->mTextInput->mScrollPosition;
+    return mImpl->mEventData->mScrollPosition;
   }
 
   return Vector2::ZERO;
@@ -1292,6 +500,7 @@ const Vector2& Controller::GetAlignmentOffset() const
 
 Vector3 Controller::GetNaturalSize()
 {
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
   Vector3 naturalSize;
 
   // Make sure the model is up-to-date before layouting
@@ -1309,7 +518,7 @@ Vector3 Controller::GetNaturalSize()
                                                                            SHAPE_TEXT        |
                                                                            GET_GLYPH_METRICS );
     // Make sure the model is up-to-date before layouting
-    UpdateModel( onlyOnceOperations );
+    mImpl->UpdateModel( onlyOnceOperations );
 
     // Operations that need to be done if the size changes.
     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
@@ -1332,17 +541,25 @@ Vector3 Controller::GetNaturalSize()
     mImpl->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
 
     mImpl->mRecalculateNaturalSize = false;
+
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
   }
   else
   {
     naturalSize = mImpl->mVisualModel->GetNaturalSize();
+
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
   }
 
+  naturalSize.x = ConvertToEven( naturalSize.x );
+  naturalSize.y = ConvertToEven( naturalSize.y );
+
   return naturalSize;
 }
 
 float Controller::GetHeightForWidth( float width )
 {
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetHeightForWidth %p width %f\n", this, width );
   // Make sure the model is up-to-date before layouting
   ProcessModifyEvents();
 
@@ -1359,7 +576,7 @@ float Controller::GetHeightForWidth( float width )
                                                                            SHAPE_TEXT        |
                                                                            GET_GLYPH_METRICS );
     // Make sure the model is up-to-date before layouting
-    UpdateModel( onlyOnceOperations );
+    mImpl->UpdateModel( onlyOnceOperations );
 
     // Operations that need to be done if the size changes.
     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
@@ -1376,10 +593,12 @@ float Controller::GetHeightForWidth( float width )
 
     // Do the size related operations again.
     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height );
   }
   else
   {
     layoutSize = mImpl->mVisualModel->GetActualSize();
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth cached %f\n", layoutSize.height );
   }
 
   return layoutSize.height;
@@ -1387,21 +606,25 @@ float Controller::GetHeightForWidth( float width )
 
 bool Controller::Relayout( const Size& size )
 {
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f\n", this, size.width, size.height );
+
   if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
   {
     bool glyphsRemoved( false );
-    if( 0u != mImpl->mVisualModel->GetNumberOfGlyphPositions() )
+    if( 0u != mImpl->mVisualModel->mGlyphPositions.Count() )
     {
-      mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
+      mImpl->mVisualModel->mGlyphPositions.Clear();
       glyphsRemoved = true;
     }
-
     // Not worth to relayout if width or height is equal to zero.
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n" );
     return glyphsRemoved;
   }
 
   if( size != mImpl->mControlSize )
   {
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mControlSize.width, mImpl->mControlSize.height );
+
     // Operations that need to be done if the size changes.
     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
                                                              LAYOUT                    |
@@ -1414,7 +637,7 @@ bool Controller::Relayout( const Size& size )
 
   // Make sure the model is up-to-date before layouting
   ProcessModifyEvents();
-  UpdateModel( mImpl->mOperationsPending );
+  mImpl->UpdateModel( mImpl->mOperationsPending );
 
   Size layoutSize;
   bool updated = DoRelayout( mImpl->mControlSize,
@@ -1427,12 +650,13 @@ bool Controller::Relayout( const Size& size )
   // After doing the text layout, the alignment offset to place the actor in the desired position can be calculated.
   CalculateTextAlignment( size );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
     // Move the cursor, grab handle etc.
-    updated = mImpl->mTextInput->ProcessInputEvents( mImpl->mControlSize, mImpl->mAlignmentOffset ) || updated;
+    updated = mImpl->ProcessInputEvents() || updated;
   }
 
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
   return updated;
 }
 
@@ -1442,20 +666,24 @@ void Controller::ProcessModifyEvents()
 
   for( unsigned int i=0; i<events.size(); ++i )
   {
-    if( REPLACE_TEXT == events[0].type )
+    if( ModifyEvent::TEXT_REPLACED == events[0].type )
     {
       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
-      DALI_ASSERT_DEBUG( 0 == i && "Unexpected REPLACE event" );
+      DALI_ASSERT_DEBUG( 0 == i && "Unexpected TEXT_REPLACED event" );
 
-      ReplaceTextEvent( events[0].text );
+      TextReplacedEvent();
     }
-    else if( INSERT_TEXT == events[0].type )
+    else if( ModifyEvent::TEXT_INSERTED == events[0].type )
     {
-      InsertTextEvent( events[0].text );
+      TextInsertedEvent();
     }
-    else if( DELETE_TEXT == events[0].type )
+    else if( ModifyEvent::TEXT_DELETED == events[0].type )
     {
-      DeleteTextEvent();
+      // Placeholder-text cannot be deleted
+      if( !mImpl->IsShowingPlaceholderText() )
+      {
+        TextDeletedEvent();
+      }
     }
   }
 
@@ -1463,326 +691,115 @@ void Controller::ProcessModifyEvents()
   events.clear();
 }
 
-void Controller::ReplaceTextEvent( const std::string& text )
+void Controller::ResetText()
 {
   // Reset buffers.
   mImpl->mLogicalModel->mText.Clear();
-  mImpl->mLogicalModel->mScriptRuns.Clear();
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mLogicalModel->mLineBreakInfo.Clear();
-  mImpl->mLogicalModel->mWordBreakInfo.Clear();
-  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
-  mImpl->mLogicalModel->mCharacterDirections.Clear();
-  mImpl->mLogicalModel->mBidirectionalLineInfo.Clear();
-  mImpl->mLogicalModel->mLogicalToVisualMap.Clear();
-  mImpl->mLogicalModel->mVisualToLogicalMap.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
+  ClearModelData();
 
-  //  Convert text into UTF-32
-  Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
-  utf32Characters.Resize( text.size() );
+  // We have cleared everything including the placeholder-text
+  mImpl->PlaceholderCleared();
 
-  // This is a bit horrible but std::string returns a (signed) char*
-  const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
+  // The natural size needs to be re-calculated.
+  mImpl->mRecalculateNaturalSize = true;
 
-  // Transform a text array encoded in utf8 into an array encoded in utf32.
-  // It returns the actual number of characters.
-  Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
-  utf32Characters.Resize( characterCount );
+  // Apply modifications to the model
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+}
 
+void Controller::ResetCursorPosition( CharacterIndex cursorIndex )
+{
   // Reset the cursor position
-  if( mImpl->mTextInput )
+  if( NULL != mImpl->mEventData )
+  {
+    mImpl->mEventData->mPrimaryCursorPosition = cursorIndex;
+
+    // Update the cursor if it's in editing mode.
+    if( ( EventData::EDITING == mImpl->mEventData->mState ) ||
+        ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) )
+    {
+      mImpl->mEventData->mUpdateCursorPosition = true;
+    }
+  }
+}
+
+void Controller::ResetScrollPosition()
+{
+  if( NULL != mImpl->mEventData )
   {
-    mImpl->mTextInput->mPrimaryCursorPosition = characterCount;
-    // TODO - handle secondary cursor
+    // Reset the scroll position.
+    mImpl->mEventData->mScrollPosition = Vector2::ZERO;
+    mImpl->mEventData->mScrollAfterUpdatePosition = true;
   }
+}
+
+void Controller::TextReplacedEvent()
+{
+  // Reset buffers.
+  ClearModelData();
 
   // The natural size needs to be re-calculated.
   mImpl->mRecalculateNaturalSize = true;
 
   // Apply modifications to the model
   mImpl->mOperationsPending = ALL_OPERATIONS;
-  UpdateModel( ALL_OPERATIONS );
+  mImpl->UpdateModel( ALL_OPERATIONS );
   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
                                                            ALIGN              |
                                                            UPDATE_ACTUAL_SIZE |
                                                            REORDER );
 }
 
-void Controller::InsertTextEvent( const std::string& text )
+void Controller::TextInsertedEvent()
 {
-  DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextInsertedEvent" );
 
   // TODO - Optimize this
-  mImpl->mLogicalModel->mScriptRuns.Clear();
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mLogicalModel->mLineBreakInfo.Clear();
-  mImpl->mLogicalModel->mWordBreakInfo.Clear();
-  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
-  mImpl->mLogicalModel->mCharacterDirections.Clear();
-  mImpl->mLogicalModel->mBidirectionalLineInfo.Clear();
-  mImpl->mLogicalModel->mLogicalToVisualMap.Clear();
-  mImpl->mLogicalModel->mVisualToLogicalMap.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
-
-  //  Convert text into UTF-32
-  Vector<Character> utf32Characters;
-  utf32Characters.Resize( text.size() );
-
-  // This is a bit horrible but std::string returns a (signed) char*
-  const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
-
-  // Transform a text array encoded in utf8 into an array encoded in utf32.
-  // It returns the actual number of characters.
-  Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
-  utf32Characters.Resize( characterCount );
-
-  // Insert at current cursor position
-  Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
-  CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
-
-  if( cursorIndex < modifyText.Count() )
-  {
-    modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.End() );
-  }
-  else
-  {
-    modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.End() );
-  }
-
-  // Advance the cursor position
-  ++cursorIndex;
+  ClearModelData();
 
   // The natural size needs to be re-calculated.
   mImpl->mRecalculateNaturalSize = true;
 
   // Apply modifications to the model; TODO - Optimize this
   mImpl->mOperationsPending = ALL_OPERATIONS;
-  UpdateModel( ALL_OPERATIONS );
+  mImpl->UpdateModel( ALL_OPERATIONS );
   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
                                                            ALIGN              |
                                                            UPDATE_ACTUAL_SIZE |
                                                            REORDER );
 
   // Queue a cursor reposition event; this must wait until after DoRelayout()
-  mImpl->mTextInput->mUpdateCursorPosition = true;
+  mImpl->mEventData->mUpdateCursorPosition = true;
+  mImpl->mEventData->mScrollAfterUpdatePosition = true;
 }
 
-void Controller::DeleteTextEvent()
+void Controller::TextDeletedEvent()
 {
-  DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextDeletedEvent" );
 
   // TODO - Optimize this
-  mImpl->mLogicalModel->mScriptRuns.Clear();
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mLogicalModel->mLineBreakInfo.Clear();
-  mImpl->mLogicalModel->mWordBreakInfo.Clear();
-  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
-  mImpl->mLogicalModel->mCharacterDirections.Clear();
-  mImpl->mLogicalModel->mBidirectionalLineInfo.Clear();
-  mImpl->mLogicalModel->mLogicalToVisualMap.Clear();
-  mImpl->mLogicalModel->mVisualToLogicalMap.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
-  mImpl->mVisualModel->mCharactersToGlyph.Clear();
-  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
-  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
-  mImpl->mVisualModel->mGlyphPositions.Clear();
-  mImpl->mVisualModel->mLines.Clear();
-  mImpl->mVisualModel->ClearCaches();
-
-  // Delte at current cursor position
-  Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
-  CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
-
-  if( cursorIndex > 0 &&
-      cursorIndex-1 < modifyText.Count() )
-  {
-    modifyText.Remove( modifyText.Begin() + cursorIndex - 1 );
-
-    // Cursor position retreat
-    --cursorIndex;
-  }
+  ClearModelData();
 
   // The natural size needs to be re-calculated.
   mImpl->mRecalculateNaturalSize = true;
 
   // Apply modifications to the model; TODO - Optimize this
   mImpl->mOperationsPending = ALL_OPERATIONS;
-  UpdateModel( ALL_OPERATIONS );
+  mImpl->UpdateModel( ALL_OPERATIONS );
   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
                                                            ALIGN              |
                                                            UPDATE_ACTUAL_SIZE |
                                                            REORDER );
 
   // Queue a cursor reposition event; this must wait until after DoRelayout()
-  mImpl->mTextInput->mUpdateCursorPosition = true;
-}
-
-void Controller::UpdateModel( OperationsMask operationsRequired )
-{
-  // Calculate the operations to be done.
-  const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
-
-  Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
-
-  const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
-
-  Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
-  if( 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'.
-    // It's also used to layout the text (where it should be a new line) or to shape the text (text in different lines
-    // is not shaped together).
-    lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK );
-
-    SetLineBreakInfo( utf32Characters,
-                      lineBreakInfo );
-  }
-
-  Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
-  if( 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 );
-
-    SetWordBreakInfo( utf32Characters,
-                      wordBreakInfo );
-  }
-
-  const bool getScripts = GET_SCRIPTS & operations;
-  const bool validateFonts = VALIDATE_FONTS & operations;
-
-  Vector<ScriptRun>& scripts = mImpl->mLogicalModel->mScriptRuns;
-  Vector<FontRun>& validFonts = mImpl->mLogicalModel->mFontRuns;
-
-  if( getScripts || validateFonts )
-  {
-    // Validates the fonts assigned by the application or assigns default ones.
-    // It makes sure all the characters are going to be rendered by the correct font.
-    MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
-
-    if( getScripts )
-    {
-      // Retrieves the scripts used in the text.
-      multilanguageSupport.SetScripts( utf32Characters,
-                                       lineBreakInfo,
-                                       scripts );
-    }
-
-    if( validateFonts )
-    {
-      if( 0u == validFonts.Count() )
-      {
-        // Copy the requested font defaults received via the property system.
-        // These may not be valid i.e. may not contain glyphs for the necessary scripts.
-        GetDefaultFonts( validFonts, numberOfCharacters );
-      }
-
-      // Validates the fonts. If there is a character with no assigned font it sets a default one.
-      // After this call, fonts are validated.
-      multilanguageSupport.ValidateFonts( utf32Characters,
-                                          scripts,
-                                          validFonts );
-    }
-  }
-
-  Vector<Character> mirroredUtf32Characters;
-  bool textMirrored = false;
-  if( BIDI_INFO & operations )
-  {
-    // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's
-    // bidirectional info.
-
-    Length numberOfParagraphs = 0u;
-
-    const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin();
-    for( Length index = 0u; index < numberOfCharacters; ++index )
-    {
-      if( TextAbstraction::LINE_NO_BREAK == *( lineBreakInfoBuffer + index ) )
-      {
-        ++numberOfParagraphs;
-      }
-    }
-
-    Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
-    bidirectionalInfo.Reserve( numberOfParagraphs );
-
-    // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
-    SetBidirectionalInfo( utf32Characters,
-                          scripts,
-                          lineBreakInfo,
-                          bidirectionalInfo );
-
-    if( 0u != bidirectionalInfo.Count() )
-    {
-      // This paragraph has right to left text. Some characters may need to be mirrored.
-      // TODO: consider if the mirrored string can be stored as well.
-
-      textMirrored = GetMirroredText( utf32Characters, mirroredUtf32Characters );
-
-      // Only set the character directions if there is right to left characters.
-      Vector<CharacterDirection>& directions = mImpl->mLogicalModel->mCharacterDirections;
-      directions.Resize( numberOfCharacters );
-
-      GetCharactersDirection( bidirectionalInfo,
-                              directions );
-    }
-    else
-    {
-      // There is no right to left characters. Clear the directions vector.
-      mImpl->mLogicalModel->mCharacterDirections.Clear();
-    }
-
-   }
-
-  Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
-  Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
-  Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
-  if( SHAPE_TEXT & operations )
-  {
-    const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
-    // Shapes the text.
-    ShapeText( textToShape,
-               lineBreakInfo,
-               scripts,
-               validFonts,
-               glyphs,
-               glyphsToCharactersMap,
-               charactersPerGlyph );
-
-    // Create the 'number of glyphs' per character and the glyph to character conversion tables.
-    mImpl->mVisualModel->CreateGlyphsPerCharacterTable( numberOfCharacters );
-    mImpl->mVisualModel->CreateCharacterToGlyphTable( numberOfCharacters );
-  }
-
-  const Length numberOfGlyphs = glyphs.Count();
-
-  if( GET_GLYPH_METRICS & operations )
-  {
-    mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs );
-  }
+  mImpl->mEventData->mScrollAfterDelete = true;
 }
 
 bool Controller::DoRelayout( const Size& size,
                              OperationsMask operationsRequired,
                              Size& layoutSize )
 {
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::DoRelayout %p size %f,%f\n", this, size.width, size.height );
   bool viewUpdated( false );
 
   // Calculate the operations to be done.
@@ -1794,16 +811,18 @@ bool Controller::DoRelayout( const Size& size,
     // after the first time the text has been laid out.
     // Fill the vectors again.
 
-    Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
+    Length numberOfGlyphs = mImpl->mVisualModel->mGlyphs.Count();
 
     if( 0u == numberOfGlyphs )
     {
       // Nothing else to do if there is no glyphs.
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout no glyphs, view updated true\n" );
       return true;
     }
 
     Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
     Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
+    Vector<CharacterDirection>& characterDirection = mImpl->mLogicalModel->mCharacterDirections;
     Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
     Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
     Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
@@ -1813,6 +832,7 @@ bool Controller::DoRelayout( const Size& size,
                                        mImpl->mLogicalModel->mText.Begin(),
                                        lineBreakInfo.Begin(),
                                        wordBreakInfo.Begin(),
+                                       ( 0u != characterDirection.Count() ) ? characterDirection.Begin() : NULL,
                                        numberOfGlyphs,
                                        glyphs.Begin(),
                                        glyphsToCharactersMap.Begin(),
@@ -1851,7 +871,7 @@ bool Controller::DoRelayout( const Size& size,
         if( 0u != bidirectionalInfo.Count() )
         {
           // Get the lines
-          const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
+          const Length numberOfLines = mImpl->mVisualModel->mLines.Count();
 
           // Reorder the lines.
           Vector<BidirectionalLineInfoRun> lineBidirectionalInfoRuns;
@@ -1892,14 +912,6 @@ bool Controller::DoRelayout( const Size& size,
         }
       } // REORDER
 
-      if( ALIGN & operations )
-      {
-        mImpl->mLayoutEngine.Align( layoutParameters,
-                                    layoutSize,
-                                    lines,
-                                    glyphPositions );
-      }
-
       // Sets the actual size.
       if( UPDATE_ACTUAL_SIZE & operations )
       {
@@ -1912,9 +924,93 @@ bool Controller::DoRelayout( const Size& size,
     layoutSize = mImpl->mVisualModel->GetActualSize();
   }
 
+  if( ALIGN & operations )
+  {
+    // The laid-out lines.
+    Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
+
+    mImpl->mLayoutEngine.Align( layoutSize,
+                                lines );
+
+    viewUpdated = true;
+  }
+
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", ( viewUpdated ? "true" : "false" ) );
   return viewUpdated;
 }
 
+void Controller::SetMultiLineEnabled( bool enable )
+{
+  const LayoutEngine::Layout layout = enable ? LayoutEngine::MULTI_LINE_BOX : LayoutEngine::SINGLE_LINE_BOX;
+
+  if( layout != mImpl->mLayoutEngine.GetLayout() )
+  {
+    // Set the layout type.
+    mImpl->mLayoutEngine.SetLayout( layout );
+
+    // Set the flags to redo the layout operations
+    const OperationsMask layoutOperations =  static_cast<OperationsMask>( LAYOUT             |
+                                                                          UPDATE_ACTUAL_SIZE |
+                                                                          ALIGN              |
+                                                                          REORDER );
+
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | layoutOperations );
+
+    mImpl->RequestRelayout();
+  }
+}
+
+bool Controller::IsMultiLineEnabled() const
+{
+  return LayoutEngine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout();
+}
+
+void Controller::SetHorizontalAlignment( LayoutEngine::HorizontalAlignment alignment )
+{
+  if( alignment != mImpl->mLayoutEngine.GetHorizontalAlignment() )
+  {
+    // Set the alignment.
+    mImpl->mLayoutEngine.SetHorizontalAlignment( alignment );
+
+    // Set the flag to redo the alignment operation.
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
+
+    mImpl->RequestRelayout();
+  }
+}
+
+LayoutEngine::HorizontalAlignment Controller::GetHorizontalAlignment() const
+{
+  return mImpl->mLayoutEngine.GetHorizontalAlignment();
+}
+
+void Controller::SetVerticalAlignment( LayoutEngine::VerticalAlignment alignment )
+{
+  if( alignment != mImpl->mLayoutEngine.GetVerticalAlignment() )
+  {
+    // Set the alignment.
+    mImpl->mLayoutEngine.SetVerticalAlignment( alignment );
+
+    // Set the flag to redo the alignment operation.
+    // TODO : Is not needed re-layout and reorder again but with the current implementation it is.
+    //        Im working on a different patch to fix an issue with the alignment. When that patch
+    //        is in, this issue can be fixed.
+    const OperationsMask layoutOperations =  static_cast<OperationsMask>( LAYOUT             |
+                                                                          UPDATE_ACTUAL_SIZE |
+                                                                          ALIGN              |
+                                                                          REORDER );
+
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | layoutOperations );
+
+    mImpl->RequestRelayout();
+  }
+}
+
+LayoutEngine::VerticalAlignment Controller::GetVerticalAlignment() const
+{
+  return mImpl->mLayoutEngine.GetVerticalAlignment();
+}
+
 void Controller::CalculateTextAlignment( const Size& size )
 {
   // Get the direction of the first character.
@@ -1979,52 +1075,59 @@ void Controller::CalculateTextAlignment( const Size& size )
   }
 }
 
-View& Controller::GetView()
-{
-  return mImpl->mView;
-}
-
 LayoutEngine& Controller::GetLayoutEngine()
 {
   return mImpl->mLayoutEngine;
 }
 
-void Controller::RequestRelayout()
+View& Controller::GetView()
 {
-  mImpl->mControlInterface.RequestTextRelayout();
+  return mImpl->mView;
 }
 
 void Controller::KeyboardFocusGainEvent()
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusGainEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    TextInput::Event event( TextInput::KEYBOARD_FOCUS_GAIN_EVENT );
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    mImpl->ChangeState( EventData::EDITING );
 
-    RequestRelayout();
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      // Show alternative placeholder-text when editing
+      ShowPlaceholderText();
+    }
+
+    mImpl->RequestRelayout();
   }
 }
 
 void Controller::KeyboardFocusLostEvent()
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusLostEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    TextInput::Event event( TextInput::KEYBOARD_FOCUS_LOST_EVENT );
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    mImpl->ChangeState( EventData::INACTIVE );
 
-    RequestRelayout();
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      // Revert to regular placeholder-text when not editing
+      ShowPlaceholderText();
+    }
+
+    mImpl->RequestRelayout();
   }
 }
 
 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyEvent" );
+
+  bool textChanged( false );
 
-  if( mImpl->mTextInput &&
+  if( mImpl->mEventData &&
       keyEvent.state == KeyEvent::Down )
   {
     int keyCode = keyEvent.keyCode;
@@ -2041,87 +1144,630 @@ bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
              Dali::DALI_KEY_CURSOR_UP    == keyCode ||
              Dali::DALI_KEY_CURSOR_DOWN  == keyCode )
     {
-      TextInput::Event event( TextInput::CURSOR_KEY_EVENT );
+      Event event( Event::CURSOR_KEY_EVENT );
       event.p1.mInt = keyCode;
-      mImpl->mTextInput->mEventQueue.push_back( event );
+      mImpl->mEventData->mEventQueue.push_back( event );
     }
     else if( Dali::DALI_KEY_BACKSPACE == keyCode )
     {
-      // Queue a delete event
-      ModifyEvent event;
-      event.type = DELETE_TEXT;
-      mImpl->mModifyEvents.push_back( event );
+      textChanged = BackspaceKeyEvent();
     }
-    else if( !keyString.empty() )
+    else if ( IsKey( keyEvent,  Dali::DALI_KEY_POWER ) || IsKey( keyEvent, Dali::DALI_KEY_MENU ) )
     {
-      // Queue an insert event
-      ModifyEvent event;
-      event.type = INSERT_TEXT;
-      event.text = keyString;
-      mImpl->mModifyEvents.push_back( event );
+      // Do nothing when the Power or Menu Key is pressed.
+      // It avoids call the InsertText() method and delete the selected text.
+    }
+    else
+    {
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", this, keyString.c_str() );
+
+      // IMF manager is no longer handling key-events
+      mImpl->ClearPreEditFlag();
+
+      InsertText( keyString, COMMIT );
+      textChanged = true;
     }
 
-    mImpl->mTextInput->ChangeState( TextInput::EDITING ); // todo Confirm this is the best place to change the state of
+    mImpl->ChangeState( EventData::EDITING ); // todo Confirm this is the best place to change the state of
 
-    RequestRelayout();
+    mImpl->RequestRelayout();
+  }
+
+  if( textChanged )
+  {
+    // Do this last since it provides callbacks into application code
+    mImpl->mControlInterface.TextChanged();
   }
 
   return false;
 }
 
+void Controller::InsertText( const std::string& text, Controller::InsertType type )
+{
+  bool removedPrevious( false );
+  bool maxLengthReached( false );
+
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected InsertText" )
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::InsertText %p %s (%s) mPrimaryCursorPosition %d mPreEditFlag %d mPreEditStartPosition %d mPreEditLength %d\n",
+                 this, text.c_str(), (COMMIT == type ? "COMMIT" : "PRE_EDIT"),
+                 mImpl->mEventData->mPrimaryCursorPosition, mImpl->mEventData->mPreEditFlag, mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
+
+  Vector<Character> utf32Characters;
+  Length characterCount( 0u );
+
+  // Remove the previous IMF pre-edit (predicitive text)
+  if( mImpl->mEventData &&
+      mImpl->mEventData->mPreEditFlag &&
+      0 != mImpl->mEventData->mPreEditLength )
+  {
+    CharacterIndex offset = mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition;
+    removedPrevious = RemoveText( -static_cast<int>(offset), mImpl->mEventData->mPreEditLength );
+
+    mImpl->mEventData->mPrimaryCursorPosition = mImpl->mEventData->mPreEditStartPosition;
+    mImpl->mEventData->mPreEditLength = 0;
+  }
+  else
+  {
+    // Remove the previous Selection
+    removedPrevious = RemoveSelectedText();
+  }
+
+  if( ! text.empty() )
+  {
+    //  Convert text into UTF-32
+    utf32Characters.Resize( text.size() );
+
+    // This is a bit horrible but std::string returns a (signed) char*
+    const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
+
+    // Transform a text array encoded in utf8 into an array encoded in utf32.
+    // It returns the actual number of characters.
+    characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
+    utf32Characters.Resize( characterCount );
+
+    DALI_ASSERT_DEBUG( text.size() >= utf32Characters.Count() && "Invalid UTF32 conversion length" );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "UTF8 size %d, UTF32 size %d\n", text.size(), utf32Characters.Count() );
+  }
+
+  if( 0u != utf32Characters.Count() ) // Check if Utf8ToUtf32 conversion succeeded
+  {
+    // The placeholder text is no longer needed
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      ResetText();
+    }
+
+    mImpl->ChangeState( EventData::EDITING );
+
+    // Handle the IMF (predicitive text) state changes
+    if( mImpl->mEventData )
+    {
+      if( COMMIT == type )
+      {
+        // IMF manager is no longer handling key-events
+        mImpl->ClearPreEditFlag();
+      }
+      else // PRE_EDIT
+      {
+        if( ! mImpl->mEventData->mPreEditFlag )
+        {
+          DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Entered PreEdit state" );
+
+          // Record the start of the pre-edit text
+          mImpl->mEventData->mPreEditStartPosition = mImpl->mEventData->mPrimaryCursorPosition;
+        }
+
+        mImpl->mEventData->mPreEditLength = utf32Characters.Count();
+        mImpl->mEventData->mPreEditFlag = true;
+
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "mPreEditStartPosition %d mPreEditLength %d\n", mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
+      }
+    }
+
+    const Length numberOfCharactersInModel = mImpl->mLogicalModel->mText.Count();
+
+    // Restrict new text to fit within Maximum characters setting
+    Length maxSizeOfNewText = std::min ( ( mImpl->mMaximumNumberOfCharacters - numberOfCharactersInModel ), characterCount );
+    maxLengthReached = ( characterCount > maxSizeOfNewText );
+
+    // Insert at current cursor position
+    CharacterIndex& cursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
+
+    Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
+
+    if( cursorIndex < numberOfCharactersInModel )
+    {
+      modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
+    }
+    else
+    {
+      modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
+    }
+
+    cursorIndex += maxSizeOfNewText;
+
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Inserted %d characters, new size %d new cursor %d\n", maxSizeOfNewText, mImpl->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition );
+  }
+
+  if( 0u == mImpl->mLogicalModel->mText.Count() &&
+      mImpl->IsPlaceholderAvailable() )
+  {
+    // Show place-holder if empty after removing the pre-edit text
+    ShowPlaceholderText();
+    mImpl->mEventData->mUpdateCursorPosition = true;
+    mImpl->ClearPreEditFlag();
+  }
+  else if( removedPrevious ||
+           0 != utf32Characters.Count() )
+  {
+    // Queue an inserted event
+    mImpl->QueueModifyEvent( ModifyEvent::TEXT_INSERTED );
+  }
+
+  if( maxLengthReached )
+  {
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mLogicalModel->mText.Count() );
+
+    mImpl->ResetImfManager();
+
+    // Do this last since it provides callbacks into application code
+    mImpl->mControlInterface.MaxLengthReached();
+  }
+}
+
+bool Controller::RemoveSelectedText()
+{
+  bool textRemoved( false );
+
+  if ( EventData::SELECTING         == mImpl->mEventData->mState ||
+       EventData::SELECTION_CHANGED == mImpl->mEventData->mState )
+  {
+    std::string removedString;
+    mImpl->RetrieveSelection( removedString, true );
+
+    if( !removedString.empty() )
+    {
+      textRemoved = true;
+      mImpl->ChangeState( EventData::EDITING );
+    }
+  }
+
+  return textRemoved;
+}
+
 void Controller::TapEvent( unsigned int tapCount, float x, float y )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected TapEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected TapEvent" );
 
-  if( mImpl->mTextInput )
+  if( NULL != mImpl->mEventData )
   {
-    TextInput::Event event( TextInput::TAP_EVENT );
-    event.p1.mUint = tapCount;
-    event.p2.mFloat = x;
-    event.p3.mFloat = y;
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    const bool isShowingPlaceholderText = mImpl->IsShowingPlaceholderText();
+    if( 1u == tapCount )
+    {
+      if( !isShowingPlaceholderText &&
+          ( EventData::EDITING == mImpl->mEventData->mState ) )
+      {
+        mImpl->mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        mImpl->mEventData->mDecorator->SetPopupActive( false );
+      }
+
+      mImpl->ChangeState( EventData::EDITING );
 
-    RequestRelayout();
+      // Handles & cursors must be repositioned after Relayout() i.e. after the Model has been updated
+      if( mImpl->mEventData )
+      {
+        Event event( Event::TAP_EVENT );
+        event.p1.mUint = tapCount;
+        event.p2.mFloat = x;
+        event.p3.mFloat = y;
+        mImpl->mEventData->mEventQueue.push_back( event );
+
+        mImpl->RequestRelayout();
+      }
+    }
+    else if( !isShowingPlaceholderText &&
+             mImpl->mEventData->mSelectionEnabled &&
+             ( 2u == tapCount ) )
+    {
+      SelectEvent( x, y, false );
+    }
   }
+
+  // Reset keyboard as tap event has occurred.
+  mImpl->ResetImfManager();
 }
 
 void Controller::PanEvent( Gesture::State state, const Vector2& displacement )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected PanEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    TextInput::Event event( TextInput::PAN_EVENT );
+    Event event( Event::PAN_EVENT );
     event.p1.mInt = state;
     event.p2.mFloat = displacement.x;
     event.p3.mFloat = displacement.y;
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    mImpl->mEventData->mEventQueue.push_back( event );
 
-    RequestRelayout();
+    mImpl->RequestRelayout();
   }
 }
 
-void Controller::GrabHandleEvent( GrabHandleState state, float x, float y )
+void Controller::SelectEvent( float x, float y, bool selectAll )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected GrabHandleEvent" );
+  if( mImpl->mEventData )
+  {
+    if ( mImpl->mEventData->mState == EventData::SELECTING )
+    {
+      mImpl->ChangeState( EventData::SELECTION_CHANGED );
+    }
+    else
+    {
+      mImpl->ChangeState( EventData::SELECTING );
+    }
+
+    if( selectAll )
+    {
+      Event event( Event::SELECT_ALL );
+      mImpl->mEventData->mEventQueue.push_back( event );
+    }
+    else
+    {
+      Event event( Event::SELECT );
+      event.p2.mFloat = x;
+      event.p3.mFloat = y;
+      mImpl->mEventData->mEventQueue.push_back( event );
+    }
 
-  if( mImpl->mTextInput )
+    mImpl->RequestRelayout();
+  }
+}
+
+void Controller::GetTargetSize( Vector2& targetSize )
+{
+  targetSize = mImpl->mControlSize;
+}
+
+void Controller::AddDecoration( Actor& actor, bool needsClipping )
+{
+  mImpl->mControlInterface.AddDecoration( actor, needsClipping );
+}
+
+void Controller::DecorationEvent( HandleType handleType, HandleState state, float x, float y )
+{
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected DecorationEvent" );
+
+  if( mImpl->mEventData )
   {
-    TextInput::Event event( TextInput::GRAB_HANDLE_EVENT );
-    event.p1.mUint  = state;
-    event.p2.mFloat = x;
-    event.p3.mFloat = y;
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    switch( handleType )
+    {
+      case GRAB_HANDLE:
+      {
+        Event event( Event::GRAB_HANDLE_EVENT );
+        event.p1.mUint  = state;
+        event.p2.mFloat = x;
+        event.p3.mFloat = y;
+
+        mImpl->mEventData->mEventQueue.push_back( event );
+        break;
+      }
+      case LEFT_SELECTION_HANDLE:
+      {
+        Event event( Event::LEFT_SELECTION_HANDLE_EVENT );
+        event.p1.mUint  = state;
+        event.p2.mFloat = x;
+        event.p3.mFloat = y;
 
-    RequestRelayout();
+        mImpl->mEventData->mEventQueue.push_back( event );
+        break;
+      }
+      case RIGHT_SELECTION_HANDLE:
+      {
+        Event event( Event::RIGHT_SELECTION_HANDLE_EVENT );
+        event.p1.mUint  = state;
+        event.p2.mFloat = x;
+        event.p3.mFloat = y;
+
+        mImpl->mEventData->mEventQueue.push_back( event );
+        break;
+      }
+      case HANDLE_TYPE_COUNT:
+      {
+        DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
+      }
+    }
+
+    mImpl->RequestRelayout();
   }
 }
 
+void Controller::PasteText( const std::string& stringToPaste )
+{
+  InsertText( stringToPaste, Text::Controller::COMMIT );
+  mImpl->ChangeState( EventData::EDITING );
+  mImpl->RequestRelayout();
+}
+
+void Controller::PasteClipboardItemEvent()
+{
+  ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
+  std::string stringToPaste( notifier.GetContent() );
+  PasteText( stringToPaste );
+}
+
+void Controller::TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::Buttons button )
+{
+  if( NULL == mImpl->mEventData )
+  {
+    return;
+  }
+
+  switch( button )
+  {
+    case Toolkit::TextSelectionPopup::CUT:
+    {
+      mImpl->SendSelectionToClipboard( true ); // Synchronous call to modify text
+      mImpl->mOperationsPending = ALL_OPERATIONS;
+      if( 0u != mImpl->mLogicalModel->mText.Count() ||
+          !mImpl->IsPlaceholderAvailable() )
+      {
+        mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+      }
+      else
+      {
+        ShowPlaceholderText();
+        mImpl->mEventData->mUpdateCursorPosition = true;
+      }
+      mImpl->RequestRelayout();
+      mImpl->mControlInterface.TextChanged();
+      break;
+    }
+    case Toolkit::TextSelectionPopup::COPY:
+    {
+      mImpl->SendSelectionToClipboard( false ); // Text not modified
+      mImpl->RequestRelayout(); // Handles, Selection Highlight, Popup
+      break;
+    }
+    case Toolkit::TextSelectionPopup::PASTE:
+    {
+      std::string stringToPaste("");
+      mImpl->GetTextFromClipboard( 0, stringToPaste ); // Paste latest item from system clipboard
+      PasteText( stringToPaste );
+      break;
+    }
+    case Toolkit::TextSelectionPopup::SELECT:
+    {
+      const Vector2& currentCursorPosition = mImpl->mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
+
+      if( mImpl->mEventData->mSelectionEnabled  )
+      {
+        // Creates a SELECT event.
+        SelectEvent( currentCursorPosition.x, currentCursorPosition.y, false );
+      }
+      break;
+    }
+    case Toolkit::TextSelectionPopup::SELECT_ALL:
+    {
+      // Creates a SELECT_ALL event
+      SelectEvent( 0.f, 0.f, true );
+      break;
+    }
+    case Toolkit::TextSelectionPopup::CLIPBOARD:
+    {
+      mImpl->ShowClipboard();
+      break;
+    }
+    case Toolkit::TextSelectionPopup::NONE:
+    {
+      // Nothing to do.
+      break;
+    }
+  }
+}
+
+ImfManager::ImfCallbackData Controller::OnImfEvent( ImfManager& imfManager, const ImfManager::ImfEventData& imfEvent )
+{
+  bool update( false );
+  bool requestRelayout = false;
+
+  std::string text;
+  unsigned int cursorPosition( 0 );
+
+  switch ( imfEvent.eventName )
+  {
+    case ImfManager::COMMIT:
+    {
+      InsertText( imfEvent.predictiveString, Text::Controller::COMMIT );
+      requestRelayout = true;
+      break;
+    }
+    case ImfManager::PREEDIT:
+    {
+      InsertText( imfEvent.predictiveString, Text::Controller::PRE_EDIT );
+      update = true;
+      requestRelayout = true;
+      break;
+    }
+    case ImfManager::DELETESURROUNDING:
+    {
+      RemoveText( imfEvent.cursorOffset, imfEvent.numberOfChars );
+      requestRelayout = true;
+      break;
+    }
+    case ImfManager::GETSURROUNDING:
+    {
+      GetText( text );
+      cursorPosition = GetLogicalCursorPosition();
+
+      imfManager.SetSurroundingText( text );
+      imfManager.SetCursorPosition( cursorPosition );
+      break;
+    }
+    case ImfManager::VOID:
+    {
+      // do nothing
+      break;
+    }
+  } // end switch
+
+  if( ImfManager::GETSURROUNDING != imfEvent.eventName )
+  {
+    GetText( text );
+    cursorPosition = GetLogicalCursorPosition();
+  }
+
+  if( requestRelayout )
+  {
+    mImpl->mOperationsPending = ALL_OPERATIONS;
+    mImpl->RequestRelayout();
+
+    // Do this last since it provides callbacks into application code
+    mImpl->mControlInterface.TextChanged();
+  }
+
+  ImfManager::ImfCallbackData callbackData( update, cursorPosition, text, false );
+
+  return callbackData;
+}
+
 Controller::~Controller()
 {
   delete mImpl;
 }
 
+bool Controller::BackspaceKeyEvent()
+{
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p DALI_KEY_BACKSPACE\n", this );
+
+  // IMF manager is no longer handling key-events
+  mImpl->ClearPreEditFlag();
+
+  bool removed( false );
+
+  if ( EventData::SELECTING         == mImpl->mEventData->mState ||
+       EventData::SELECTION_CHANGED == mImpl->mEventData->mState )
+  {
+    removed = RemoveSelectedText();
+  }
+  else if( mImpl->mEventData->mPrimaryCursorPosition > 0 )
+  {
+    // Remove the character before the current cursor position
+    removed = RemoveText( -1, 1 );
+  }
+
+  if( removed )
+  {
+    if( 0u != mImpl->mLogicalModel->mText.Count() ||
+        !mImpl->IsPlaceholderAvailable() )
+    {
+      mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+    }
+    else
+    {
+      ShowPlaceholderText();
+      mImpl->mEventData->mUpdateCursorPosition = true;
+    }
+  }
+
+  return removed;
+}
+
+void Controller::ShowPlaceholderText()
+{
+  if( mImpl->IsPlaceholderAvailable() )
+  {
+    DALI_ASSERT_DEBUG( mImpl->mEventData && "No placeholder text available" );
+
+    mImpl->mEventData->mIsShowingPlaceholderText = true;
+
+    // Disable handles when showing place-holder text
+    mImpl->mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
+    mImpl->mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+    mImpl->mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+
+    const char* text( NULL );
+    size_t size( 0 );
+
+    // TODO - Switch placeholder text styles when changing state
+    if( EventData::INACTIVE != mImpl->mEventData->mState &&
+        0u != mImpl->mEventData->mPlaceholderTextActive.c_str() )
+    {
+      text = mImpl->mEventData->mPlaceholderTextActive.c_str();
+      size = mImpl->mEventData->mPlaceholderTextActive.size();
+    }
+    else
+    {
+      text = mImpl->mEventData->mPlaceholderTextInactive.c_str();
+      size = mImpl->mEventData->mPlaceholderTextInactive.size();
+    }
+
+    // Reset model for showing placeholder.
+    mImpl->mLogicalModel->mText.Clear();
+    ClearModelData();
+    mImpl->mVisualModel->SetTextColor( mImpl->mEventData->mPlaceholderTextColor );
+
+    // Convert text into UTF-32
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
+    utf32Characters.Resize( size );
+
+    // This is a bit horrible but std::string returns a (signed) char*
+    const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text );
+
+    // Transform a text array encoded in utf8 into an array encoded in utf32.
+    // It returns the actual number of characters.
+    Length characterCount = Utf8ToUtf32( utf8, size, utf32Characters.Begin() );
+    utf32Characters.Resize( characterCount );
+
+    // Reset the cursor position
+    mImpl->mEventData->mPrimaryCursorPosition = 0;
+
+    // The natural size needs to be re-calculated.
+    mImpl->mRecalculateNaturalSize = true;
+
+    // Apply modifications to the model
+    mImpl->mOperationsPending = ALL_OPERATIONS;
+
+    // Update the rest of the model during size negotiation
+    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
+  }
+}
+
+void Controller::ClearModelData()
+{
+  // n.b. This does not Clear the mText from mLogicalModel
+  mImpl->mLogicalModel->mScriptRuns.Clear();
+  mImpl->mLogicalModel->mFontRuns.Clear();
+  mImpl->mLogicalModel->mLineBreakInfo.Clear();
+  mImpl->mLogicalModel->mWordBreakInfo.Clear();
+  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
+  mImpl->mLogicalModel->mCharacterDirections.Clear();
+  mImpl->mLogicalModel->mBidirectionalLineInfo.Clear();
+  mImpl->mLogicalModel->mLogicalToVisualMap.Clear();
+  mImpl->mLogicalModel->mVisualToLogicalMap.Clear();
+  mImpl->mVisualModel->mGlyphs.Clear();
+  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
+  mImpl->mVisualModel->mCharactersToGlyph.Clear();
+  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
+  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
+  mImpl->mVisualModel->mGlyphPositions.Clear();
+  mImpl->mVisualModel->mLines.Clear();
+  mImpl->mVisualModel->ClearCaches();
+}
+
+void Controller::ClearFontData()
+{
+  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
+  mImpl->mLogicalModel->mFontRuns.Clear();
+  mImpl->mVisualModel->mGlyphs.Clear();
+  mImpl->mVisualModel->mGlyphsToCharacters.Clear();
+  mImpl->mVisualModel->mCharactersToGlyph.Clear();
+  mImpl->mVisualModel->mCharactersPerGlyph.Clear();
+  mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
+  mImpl->mVisualModel->mGlyphPositions.Clear();
+  mImpl->mVisualModel->mLines.Clear();
+  mImpl->mVisualModel->ClearCaches();
+}
+
 Controller::Controller( ControlInterface& controlInterface )
 : mImpl( NULL )
 {