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=36b566b7052626c1fc34932c8f2b641c9a7d97cf;hp=ea3369542df9e98e56e5be500a7a51efdd5fb446;hb=2a9ea91b7a05e1cf6d50e08425a7607bebab099f;hpb=b0d779c1461781f29868f5414d2475ab0ba9766b

diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp
index ea33695..36b566b 100644
--- a/dali-toolkit/internal/text/text-controller.cpp
+++ b/dali-toolkit/internal/text/text-controller.cpp
@@ -20,44 +20,32 @@
 
 // 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>
 
 // 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
 {
 
-const float MAX_FLOAT = std::numeric_limits<float>::max();
-const std::string EMPTY_STRING;
+#if defined(DEBUG_ENABLED)
+  Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
+#endif
 
-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 float MAX_FLOAT = std::numeric_limits<float>::max();
 
-struct ModifyEvent
-{
-  ModifyType type;
-  std::string text;
-};
+const std::string EMPTY_STRING("");
 
 } // namespace
 
@@ -70,437 +58,174 @@ namespace Toolkit
 namespace Text
 {
 
-struct Controller::TextInput
+ControllerPtr Controller::New( ControlInterface& controlInterface )
 {
-  // Used to queue input events until DoRelayout()
-  enum EventType
-  {
-    KEYBOARD_FOCUS_GAIN_EVENT,
-    KEYBOARD_FOCUS_LOST_EVENT,
-    CURSOR_KEY_EVENT,
-    TAP_EVENT,
-    GRAB_HANDLE_EVENT
-  };
-
-  union Param
-  {
-    int mInt;
-    unsigned int mUint;
-    float mFloat;
-  };
-
-  struct Event
-  {
-    Event( EventType eventType )
-    : type( eventType )
-    {
-      p1.mInt = 0;
-      p2.mInt = 0;
-    }
-
-    EventType type;
-    Param p1;
-    Param p2;
-    Param p3;
-  };
-
-  enum State
-  {
-    INACTIVE,
-    SELECTING,
-    EDITING
-  };
-
-  TextInput( LogicalModelPtr logicalModel,
-             VisualModelPtr visualModel,
-             DecoratorPtr decorator )
-  : mLogicalModel( logicalModel ),
-    mVisualModel( visualModel ),
-    mDecorator( decorator ),
-    mState( INACTIVE ),
-    mPrimaryCursorPosition( 0u ),
-    mSecondaryCursorPosition( 0u ),
-    mDecoratorUpdated( false ),
-    mCursorBlinkEnabled( true )
-  {
-  }
-
-  /**
-   * @brief Helper to move the cursor, grab handle etc.
-   */
-  bool ProcessInputEvents()
-  {
-    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 );
-            break;
-          }
-          case GRAB_HANDLE_EVENT:
-          {
-            OnGrabHandleEvent( *iter );
-            break;
-          }
-        }
-      }
-    }
-
-    mEventQueue.clear();
-
-    return mDecoratorUpdated;
-  }
-
-  void OnKeyboardFocus( bool hasFocus )
-  {
-    if( !hasFocus )
-    {
-      ChangeState( INACTIVE );
-    }
-    else
-    {
-      ChangeState( EDITING );
-    }
-  }
-
-  void OnCursorKeyEvent( const Event& event )
-  {
-    int keyCode = event.p1.mInt;
-
-    if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
-    {
-      // TODO
-    }
-    else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
-    {
-      // TODO
-    }
-    else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
-    {
-      // TODO
-    }
-    else if(   Dali::DALI_KEY_CURSOR_DOWN == keyCode )
-    {
-      // TODO
-    }
-  }
+  return ControllerPtr( new Controller( controlInterface ) );
+}
 
-  void HandleBackspaceKey()
+void Controller::EnableTextInput( DecoratorPtr decorator )
+{
+  if( !mImpl->mEventData )
   {
-    // TODO
+    mImpl->mEventData = new EventData( decorator );
   }
+}
 
-  void HandleCursorKey( int keyCode )
-  {
-    // TODO
-  }
+void Controller::SetText( const std::string& text )
+{
+  // Remove the previously set text
+  ResetText();
 
-  void HandleKeyString( const char* keyString )
-  {
-    // TODO
-  }
+  CharacterIndex lastCursorIndex = 0u;
 
-  void OnTapEvent( const Event& event )
+  if( !text.empty() )
   {
-    unsigned int tapCount = event.p1.mUint;
-
-    if( 1u == tapCount )
-    {
-      ChangeState( EDITING );
+    //  Convert text into UTF-32
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
+    utf32Characters.Resize( text.size() );
 
-      float xPosition = event.p2.mFloat;
-      float yPosition = event.p3.mFloat;
-      float height(0.0f);
-      GetClosestCursorPosition( xPosition, yPosition, height );
-      mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
+    // This is a bit horrible but std::string returns a (signed) char*
+    const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 
-      mDecoratorUpdated = true;
-    }
-    else if( 2u == tapCount )
-    {
-      ChangeState( SELECTING );
-    }
-  }
+    // 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 );
 
-  void OnGrabHandleEvent( const Event& event )
-  {
-    unsigned int state = event.p1.mUint;
+    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() );
 
-    if( GRAB_HANDLE_PRESSED == state )
-    {
-      float xPosition = event.p2.mFloat;
-      float yPosition = event.p3.mFloat;
-      float height(0.0f);
+    // To reset the cursor position
+    lastCursorIndex = characterCount;
 
-      GetClosestCursorPosition( xPosition, yPosition, height );
+    // Update the rest of the model during size negotiation
+    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
 
-      mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
-      mDecorator->HidePopup();
-      mDecoratorUpdated = true;
-    }
-    else if ( GRAB_HANDLE_RELEASED == state )
-    {
-      mDecorator->ShowPopup();
-    }
+    // The natural size needs to be re-calculated.
+    mImpl->mRecalculateNaturalSize = true;
 
+    // Apply modifications to the model
+    mImpl->mOperationsPending = ALL_OPERATIONS;
   }
-
-  void ChangeState( State newState )
+  else
   {
-    if( mState != newState )
-    {
-      mState = newState;
-
-      if( INACTIVE == mState )
-      {
-        mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
-        mDecorator->StopCursorBlink();
-        mDecorator->SetGrabHandleActive( false );
-        mDecorator->SetSelectionActive( false );
-        mDecorator->HidePopup();
-        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();
-        }
-        mDecorator->SetGrabHandleActive( true );
-        mDecorator->SetSelectionActive( false );
-        mDecoratorUpdated = true;
-      }
-    }
+    ShowPlaceholderText();
   }
 
-  void GetClosestCursorPosition( float& x, float& y, float& height )
-  {
-    // TODO - Look at LineRuns first
-
-    Text::Length numberOfGlyphs = mVisualModel->GetNumberOfGlyphs();
-    if( 0 == numberOfGlyphs )
-    {
-      return;
-    }
-
-    Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
-    const GlyphInfo* const glyphsBuffer = glyphs.Begin();
-
-    Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
-    const Vector2* const positionsBuffer = positions.Begin();
-
-    unsigned int closestGlyph = 0;
-    float closestDistance = MAX_FLOAT;
-
-    for( unsigned int i = 0, numberOfGLyphs = glyphs.Count(); i < numberOfGLyphs; ++i )
-    {
-      const GlyphInfo& glyphInfo = *( glyphsBuffer + i );
-      const Vector2& position = *( positionsBuffer + i );
-      float glyphX = position.x + glyphInfo.width*0.5f;
-      float glyphY = position.y + glyphInfo.height*0.5f;
-
-      float distanceToGlyph = fabsf( glyphX - x ) + fabsf( glyphY - y );
+  // Resets the cursor position.
+  ResetCursorPosition( lastCursorIndex );
 
-      if( distanceToGlyph < closestDistance )
-      {
-        closestDistance = distanceToGlyph;
-        closestGlyph = i;
-      }
-    }
+  // Scrolls the text to make the cursor visible.
+  ResetScrollPosition();
 
-    // TODO - Consider RTL languages
-    x = positions[closestGlyph].x + glyphs[closestGlyph].width;
-    y = 0.0f;
+  mImpl->RequestRelayout();
 
-    FontMetrics metrics;
-    TextAbstraction::FontClient::Get().GetFontMetrics( glyphs[closestGlyph].fontId, metrics );
-    height = metrics.height; // TODO - Fix for multi-line
+  if( mImpl->mEventData )
+  {
+    // Cancel previously queued events
+    mImpl->mEventData->mEventQueue.clear();
   }
 
-  LogicalModelPtr mLogicalModel;
-  VisualModelPtr  mVisualModel;
-  DecoratorPtr    mDecorator;
-
-  std::string mPlaceholderText;
+  // Reset keyboard as text changed
+  mImpl->ResetImfManager();
 
-  /**
-   * 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
-
-  bool mDecoratorUpdated   : 1; ///< True if the decorator was updated during event processing
-  bool mCursorBlinkEnabled : 1; ///< True if cursor should blink when active
-};
+  // Do this last since it provides callbacks into application code
+  mImpl->mControlInterface.TextChanged();
+}
 
-struct Controller::FontDefaults
+void Controller::GetText( std::string& text ) const
 {
-  FontDefaults()
-  : mDefaultPointSize(0.0f),
-    mFontId(0u)
+  if( ! mImpl->IsShowingPlaceholderText() )
   {
-  }
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 
-  FontId GetFontId( TextAbstraction::FontClient& fontClient )
-  {
-    if( !mFontId )
+    if( 0u != utf32Characters.Count() )
     {
-      Dali::TextAbstraction::PointSize26Dot6 pointSize = mDefaultPointSize*64;
-      mFontId = fontClient.GetFontId( mDefaultFontFamily, mDefaultFontStyle, pointSize );
+      Utf32ToUtf8( &utf32Characters[0], utf32Characters.Count(), text );
     }
-
-    return mFontId;
   }
-
-  std::string mDefaultFontFamily;
-  std::string mDefaultFontStyle;
-  float mDefaultPointSize;
-  FontId mFontId;
-};
-
-struct Controller::Impl
-{
-  Impl( ControlInterface& controlInterface )
-  : mControlInterface( controlInterface ),
-    mLogicalModel(),
-    mVisualModel(),
-    mFontDefaults( NULL ),
-    mTextInput( NULL ),
-    mFontClient(),
-    mView(),
-    mLayoutEngine(),
-    mModifyEvents(),
-    mControlSize(),
-    mOperationsPending( NO_OPERATION ),
-    mRecalculateNaturalSize( true )
+  else
   {
-    mLogicalModel = LogicalModel::New();
-    mVisualModel  = VisualModel::New();
-
-    mFontClient = TextAbstraction::FontClient::Get();
-
-    mView.SetVisualModel( mVisualModel );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
   }
+}
 
-  ~Impl()
+unsigned int Controller::GetLogicalCursorPosition() const
+{
+  if( mImpl->mEventData )
   {
-    delete mTextInput;
+    return mImpl->mEventData->mPrimaryCursorPosition;
   }
 
-  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.
-  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 ) );
+  return 0u;
 }
 
-void Controller::SetText( const std::string& text )
+void Controller::SetPlaceholderText( PlaceholderType type, 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 )
+  if( mImpl->mEventData )
   {
-    // Cancel previously queued events
-    mImpl->mTextInput->mEventQueue.clear();
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
+    {
+      mImpl->mEventData->mPlaceholderTextInactive = text;
+    }
+    else
+    {
+      mImpl->mEventData->mPlaceholderTextActive = text;
+    }
 
-    // TODO - Hide selection decorations
+    // Update placeholder if there is no text
+    if( mImpl->IsShowingPlaceholderText() ||
+        0u == mImpl->mLogicalModel->mText.Count() )
+    {
+      ShowPlaceholderText();
+    }
   }
 }
 
-void Controller::GetText( std::string& text ) const
+void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
 {
-  if( !mImpl->mModifyEvents.empty() &&
-       REPLACE_TEXT == mImpl->mModifyEvents[0].type )
-  {
-    text = mImpl->mModifyEvents[0].text;
-  }
-  else
+  if( mImpl->mEventData )
   {
-    // TODO - Convert from UTF-32
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
+    {
+      text = mImpl->mEventData->mPlaceholderTextInactive;
+    }
+    else
+    {
+      text = mImpl->mEventData->mPlaceholderTextActive;
+    }
   }
 }
 
-void Controller::SetPlaceholderText( const std::string& text )
+void Controller::SetMaximumNumberOfCharacters( int maxCharacters )
 {
-  if( !mImpl->mTextInput )
+  if ( maxCharacters >= 0 )
   {
-    mImpl->mTextInput->mPlaceholderText = text;
+    mImpl->mMaximumNumberOfCharacters = maxCharacters;
   }
 }
 
-void Controller::GetPlaceholderText( std::string& text ) const
+int Controller::GetMaximumNumberOfCharacters()
 {
-  if( !mImpl->mTextInput )
-  {
-    text = mImpl->mTextInput->mPlaceholderText;
-  }
+  return mImpl->mMaximumNumberOfCharacters;
 }
 
 void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
 {
   if( !mImpl->mFontDefaults )
   {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
+    mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
+
+  // Clear the font-specific data
+  ClearFontData();
+
   mImpl->mOperationsPending = ALL_OPERATIONS;
   mImpl->mRecalculateNaturalSize = true;
+
+  mImpl->RequestRelayout();
 }
 
 const std::string& Controller::GetDefaultFontFamily() const
@@ -517,13 +242,18 @@ void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
 {
   if( !mImpl->mFontDefaults )
   {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
+    mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
+
+  // Clear the font-specific data
+  ClearFontData();
+
   mImpl->mOperationsPending = ALL_OPERATIONS;
   mImpl->mRecalculateNaturalSize = true;
+
+  mImpl->RequestRelayout();
 }
 
 const std::string& Controller::GetDefaultFontStyle() const
@@ -540,13 +270,18 @@ void Controller::SetDefaultPointSize( float pointSize )
 {
   if( !mImpl->mFontDefaults )
   {
-    mImpl->mFontDefaults = new Controller::FontDefaults();
+    mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mDefaultPointSize = pointSize;
-  mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
+
+  // Clear the font-specific data
+  ClearFontData();
+
   mImpl->mOperationsPending = ALL_OPERATIONS;
   mImpl->mRecalculateNaturalSize = true;
+
+  mImpl->RequestRelayout();
 }
 
 float Controller::GetDefaultPointSize() const
@@ -559,56 +294,196 @@ float Controller::GetDefaultPointSize() const
   return 0.0f;
 }
 
-void Controller::GetDefaultFonts( Vector<FontRun>& fonts, Length numberOfCharacters )
+void Controller::SetTextColor( const Vector4& textColor )
 {
-  if( mImpl->mFontDefaults )
+  mImpl->mTextColor = textColor;
+
+  if( !mImpl->IsShowingPlaceholderText() )
   {
-    FontRun fontRun;
-    fontRun.characterRun.characterIndex = 0;
-    fontRun.characterRun.numberOfCharacters = numberOfCharacters;
-    fontRun.fontId = mImpl->mFontDefaults->GetFontId( mImpl->mFontClient );
-    fontRun.isDefault = true;
+    mImpl->mVisualModel->SetTextColor( textColor );
 
-    fonts.PushBack( fontRun );
+    mImpl->RequestRelayout();
   }
 }
 
-void Controller::EnableTextInput( DecoratorPtr decorator )
+const Vector4& Controller::GetTextColor() const
+{
+  return mImpl->mTextColor;
+}
+
+bool Controller::RemoveText( int cursorOffset, int numberOfChars )
+{
+  bool removed( false );
+
+  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 );
+
+  if( ! mImpl->IsShowingPlaceholderText() )
+  {
+    // Delete at current cursor position
+    Vector<Character>& currentText = mImpl->mLogicalModel->mText;
+    CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
+
+    CharacterIndex cursorIndex = oldCursorIndex;
+
+    // Validate the cursor position & number of characters
+    if( static_cast< CharacterIndex >( std::abs( cursorOffset ) ) <= cursorIndex )
+    {
+      cursorIndex = oldCursorIndex + cursorOffset;
+    }
+
+    if( (cursorIndex + numberOfChars) > currentText.Count() )
+    {
+      numberOfChars = currentText.Count() - cursorIndex;
+    }
+
+    if( cursorIndex >= 0 &&
+        (cursorIndex + numberOfChars) <= currentText.Count() )
+    {
+      Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
+      Vector<Character>::Iterator last  = first + numberOfChars;
+
+      currentText.Erase( first, last );
+
+      // Cursor position retreat
+      oldCursorIndex = cursorIndex;
+
+      DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfChars );
+      removed = true;
+    }
+  }
+
+  return removed;
+}
+
+void Controller::SetPlaceholderTextColor( const Vector4& textColor )
+{
+  if( mImpl->mEventData )
+  {
+    mImpl->mEventData->mPlaceholderTextColor = textColor;
+  }
+
+  if( mImpl->IsShowingPlaceholderText() )
+  {
+    mImpl->mVisualModel->SetTextColor( textColor );
+    mImpl->RequestRelayout();
+  }
+}
+
+const Vector4& Controller::GetPlaceholderTextColor() const
 {
-  if( !mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    mImpl->mTextInput = new TextInput( mImpl->mLogicalModel, mImpl->mVisualModel, decorator );
+    return mImpl->mEventData->mPlaceholderTextColor;
   }
+
+  return Color::BLACK;
+}
+
+void Controller::SetShadowOffset( const Vector2& shadowOffset )
+{
+  mImpl->mVisualModel->SetShadowOffset( shadowOffset );
+
+  mImpl->RequestRelayout();
+}
+
+const Vector2& Controller::GetShadowOffset() const
+{
+  return mImpl->mVisualModel->GetShadowOffset();
+}
+
+void Controller::SetShadowColor( const Vector4& shadowColor )
+{
+  mImpl->mVisualModel->SetShadowColor( shadowColor );
+
+  mImpl->RequestRelayout();
+}
+
+const Vector4& Controller::GetShadowColor() const
+{
+  return mImpl->mVisualModel->GetShadowColor();
+}
+
+void Controller::SetUnderlineColor( const Vector4& color )
+{
+  mImpl->mVisualModel->SetUnderlineColor( color );
+
+  mImpl->RequestRelayout();
+}
+
+const Vector4& Controller::GetUnderlineColor() const
+{
+  return mImpl->mVisualModel->GetUnderlineColor();
+}
+
+void Controller::SetUnderlineEnabled( bool enabled )
+{
+  mImpl->mVisualModel->SetUnderlineEnabled( enabled );
+
+  mImpl->RequestRelayout();
+}
+
+bool Controller::IsUnderlineEnabled() const
+{
+  return mImpl->mVisualModel->IsUnderlineEnabled();
+}
+
+void Controller::SetUnderlineHeight( float height )
+{
+  mImpl->mVisualModel->SetUnderlineHeight( height );
+
+  mImpl->RequestRelayout();
+}
+
+float Controller::GetUnderlineHeight() const
+{
+  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;
 }
 
+const Vector2& Controller::GetScrollPosition() const
+{
+  if( mImpl->mEventData )
+  {
+    return mImpl->mEventData->mScrollPosition;
+  }
+
+  return Vector2::ZERO;
+}
+
+const Vector2& Controller::GetAlignmentOffset() const
+{
+  return mImpl->mAlignmentOffset;
+}
+
 Vector3 Controller::GetNaturalSize()
 {
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
   Vector3 naturalSize;
 
   // Make sure the model is up-to-date before layouting
@@ -626,10 +501,11 @@ 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 |
+                                                                        ALIGN  |
                                                                         REORDER );
 
     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
@@ -648,10 +524,14 @@ 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 );
   }
 
   return naturalSize;
@@ -659,6 +539,7 @@ Vector3 Controller::GetNaturalSize()
 
 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();
 
@@ -675,10 +556,11 @@ 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 |
+                                                                        ALIGN  |
                                                                         REORDER );
 
     DoRelayout( Size( width, MAX_FLOAT ),
@@ -691,17 +573,21 @@ 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;
 }
 
-bool Controller::Relayout( const Vector2& size )
+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 );
@@ -710,16 +596,19 @@ bool Controller::Relayout( const Vector2& size )
       mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
       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                    |
+                                                             ALIGN                     |
                                                              UPDATE_ACTUAL_SIZE        |
                                                              REORDER );
 
@@ -728,7 +617,7 @@ bool Controller::Relayout( const Vector2& 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,
@@ -738,12 +627,16 @@ bool Controller::Relayout( const Vector2& size )
   // Do not re-do any operation until something changes.
   mImpl->mOperationsPending = NO_OPERATION;
 
-  if( mImpl->mTextInput )
+  // After doing the text layout, the alignment offset to place the actor in the desired position can be calculated.
+  CalculateTextAlignment( size );
+
+  if( mImpl->mEventData )
   {
     // Move the cursor, grab handle etc.
-    updated = mImpl->mTextInput->ProcessInputEvents() || updated;
+    updated = mImpl->ProcessInputEvents() || updated;
   }
 
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
   return updated;
 }
 
@@ -753,20 +646,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();
+      }
     }
   }
 
@@ -774,273 +671,116 @@ void Controller::ProcessModifyEvents()
   events.clear();
 }
 
-void Controller::ReplaceTextEvent( const std::string& text )
+void Controller::ResetText()
 {
   // Reset buffers.
-  mImpl->mLogicalModel->mScriptRuns.Clear();
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mLogicalModel->mLineBreakInfo.Clear();
-  mImpl->mLogicalModel->mWordBreakInfo.Clear();
-  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-
-  //  Convert text into UTF-32
-  Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
-  utf32Characters.Resize( text.size() );
+  mImpl->mLogicalModel->mText.Clear();
+  ClearModelData();
 
-  // 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 );
-
-  // Reset the cursor position
-  if( mImpl->mTextInput )
-  {
-    mImpl->mTextInput->mPrimaryCursorPosition = characterCount;
-    // TODO - handle secondary cursor
-  }
+  // We have cleared everything including the placeholder-text
+  mImpl->PlaceholderCleared();
 
   // The natural size needs to be re-calculated.
   mImpl->mRecalculateNaturalSize = true;
 
   // Apply modifications to the model
   mImpl->mOperationsPending = ALL_OPERATIONS;
-  UpdateModel( ALL_OPERATIONS );
-  mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
-                                                           UPDATE_ACTUAL_SIZE |
-                                                           REORDER );
 }
 
-void Controller::InsertTextEvent( const std::string& text )
+void Controller::ResetCursorPosition( CharacterIndex cursorIndex )
 {
-  DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
-
-  // TODO - Optimize this
-  mImpl->mLogicalModel->mScriptRuns.Clear();
-  mImpl->mLogicalModel->mFontRuns.Clear();
-  mImpl->mLogicalModel->mLineBreakInfo.Clear();
-  mImpl->mLogicalModel->mWordBreakInfo.Clear();
-  mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
-  mImpl->mVisualModel->mGlyphs.Clear();
-
-  //  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() )
+  // Reset the cursor position
+  if( NULL != mImpl->mEventData )
   {
-    modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.End() );
+    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;
+    }
   }
-  else
+}
+
+void Controller::ResetScrollPosition()
+{
+  if( NULL != mImpl->mEventData )
   {
-    modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.End() );
+    // Reset the scroll position.
+    mImpl->mEventData->mScrollPosition = Vector2::ZERO;
+    mImpl->mEventData->mScrollAfterUpdateCursorPosition = true;
   }
+}
 
-  // Advance the cursor position
-  ++cursorIndex;
+void Controller::TextReplacedEvent()
+{
+  // Reset buffers.
+  ClearModelData();
 
   // The natural size needs to be re-calculated.
   mImpl->mRecalculateNaturalSize = true;
 
-  // Apply modifications to the model; TODO - Optimize this
+  // Apply modifications to the model
   mImpl->mOperationsPending = ALL_OPERATIONS;
-  UpdateModel( ALL_OPERATIONS );
-  mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
+  mImpl->UpdateModel( ALL_OPERATIONS );
+  mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
+                                                           ALIGN              |
                                                            UPDATE_ACTUAL_SIZE |
                                                            REORDER );
 }
 
-void Controller::DeleteTextEvent()
+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->mVisualModel->mGlyphs.Clear();
-
-  // 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->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
+  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->mEventData->mUpdateCursorPosition = true;
+  mImpl->mEventData->mScrollAfterUpdateCursorPosition = true;
 }
 
-void Controller::UpdateModel( OperationsMask operationsRequired )
+void Controller::TextDeletedEvent()
 {
-  // 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;
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextDeletedEvent" );
 
-    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 );
-    }
-  }
-
-  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 );
-  }
+  // TODO - Optimize this
+  ClearModelData();
 
-  const Length numberOfGlyphs = glyphs.Count();
+  // The natural size needs to be re-calculated.
+  mImpl->mRecalculateNaturalSize = true;
 
-  if( GET_GLYPH_METRICS & operations )
-  {
-    mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs );
-  }
+  // Apply modifications to the model; TODO - Optimize this
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->UpdateModel( ALL_OPERATIONS );
+  mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
+                                                           ALIGN              |
+                                                           UPDATE_ACTUAL_SIZE |
+                                                           REORDER );
 
-  if( 0u != numberOfGlyphs )
-  {
-    // Create the glyph to character conversion table and the 'number of glyphs' per character.
-    mImpl->mVisualModel->CreateCharacterToGlyphTable(numberOfCharacters );
-    mImpl->mVisualModel->CreateGlyphsPerCharacterTable( numberOfCharacters );
-  }
+  // Queue a cursor reposition event; this must wait until after DoRelayout()
+  mImpl->mEventData->mUpdateCursorPosition = true;
+  mImpl->mEventData->mScrollAfterUpdateCursorPosition = true;
 }
 
-bool Controller::DoRelayout( const Vector2& size,
+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.
@@ -1052,19 +792,28 @@ bool Controller::DoRelayout( const Vector2& size,
     // after the first time the text has been laid out.
     // Fill the vectors again.
 
-    const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
     Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
 
+    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;
 
     // Set the layout parameters.
     LayoutParameters layoutParameters( size,
+                                       mImpl->mLogicalModel->mText.Begin(),
                                        lineBreakInfo.Begin(),
                                        wordBreakInfo.Begin(),
+                                       ( 0u != characterDirection.Count() ) ? characterDirection.Begin() : NULL,
                                        numberOfGlyphs,
                                        glyphs.Begin(),
                                        glyphsToCharactersMap.Begin(),
@@ -1076,18 +825,16 @@ bool Controller::DoRelayout( const Vector2& size,
     // some re-allocations.
     Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
 
+    // Delete any previous laid out lines before setting the new ones.
+    lines.Clear();
+
+    // The capacity of the bidirectional paragraph info is the number of paragraphs.
+    lines.Reserve( mImpl->mLogicalModel->mBidirectionalParagraphInfo.Capacity() );
+
     // Resize the vector of positions to have the same size than the vector of glyphs.
     Vector<Vector2>& glyphPositions = mImpl->mVisualModel->mGlyphPositions;
     glyphPositions.Resize( numberOfGlyphs );
 
-    BidirectionalRunIndex firstBidiRunIndex = 0u;
-    Length numberOfBidiRuns = 0u;
-    mImpl->mLogicalModel->GetNumberOfBidirectionalInfoRuns( 0u, numberOfCharacters, firstBidiRunIndex, numberOfBidiRuns );
-
-    // Delete any previous laid out lines before setting the new ones.
-    lines.Clear();
-    lines.Reserve( numberOfBidiRuns );
-
     // Update the visual model.
     viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
                                                    glyphPositions,
@@ -1144,6 +891,17 @@ bool Controller::DoRelayout( const Vector2& size,
             free( bidiLineInfo.visualToLogicalMap );
           }
         }
+      } // REORDER
+
+      // TODO: I'm working on a patch that changes the LayoutEngine::Align() method.
+      //       The layoutParameters is not needed and this call can be moved outside the if().
+      //       Then there is no need to do the layout again to change the alignment.
+      if( ALIGN & operations )
+      {
+        mImpl->mLayoutEngine.Align( layoutParameters,
+                                    layoutSize,
+                                    lines,
+                                    glyphPositions );
       }
 
       // Sets the actual size.
@@ -1151,19 +909,159 @@ bool Controller::DoRelayout( const Vector2& size,
       {
         mImpl->mVisualModel->SetActualSize( layoutSize );
       }
-    }
+    } // view updated
   }
   else
   {
     layoutSize = mImpl->mVisualModel->GetActualSize();
   }
 
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", ( viewUpdated ? "true" : "false" ) );
   return viewUpdated;
 }
 
-View& Controller::GetView()
+void Controller::SetMultiLineEnabled( bool enable )
 {
-  return mImpl->mView;
+  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.
+    // 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::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.
+  const CharacterDirection firstParagraphDirection = mImpl->mLogicalModel->GetCharacterDirection( 0u );
+
+  const Size& actualSize = mImpl->mVisualModel->GetActualSize();
+
+  // If the first paragraph is right to left swap ALIGN_BEGIN and ALIGN_END;
+  LayoutEngine::HorizontalAlignment horizontalAlignment = mImpl->mLayoutEngine.GetHorizontalAlignment();
+  if( firstParagraphDirection &&
+      ( LayoutEngine::HORIZONTAL_ALIGN_CENTER != horizontalAlignment ) )
+  {
+    if( LayoutEngine::HORIZONTAL_ALIGN_BEGIN == horizontalAlignment )
+    {
+      horizontalAlignment = LayoutEngine::HORIZONTAL_ALIGN_END;
+    }
+    else
+    {
+      horizontalAlignment = LayoutEngine::HORIZONTAL_ALIGN_BEGIN;
+    }
+  }
+
+  switch( horizontalAlignment )
+  {
+    case LayoutEngine::HORIZONTAL_ALIGN_BEGIN:
+    {
+      mImpl->mAlignmentOffset.x = 0.f;
+      break;
+    }
+    case LayoutEngine::HORIZONTAL_ALIGN_CENTER:
+    {
+      const int intOffset = static_cast<int>( 0.5f * ( size.width - actualSize.width ) ); // try to avoid pixel alignment.
+      mImpl->mAlignmentOffset.x = static_cast<float>( intOffset );
+      break;
+    }
+    case LayoutEngine::HORIZONTAL_ALIGN_END:
+    {
+      mImpl->mAlignmentOffset.x = size.width - actualSize.width;
+      break;
+    }
+  }
+
+  const LayoutEngine::VerticalAlignment verticalAlignment = mImpl->mLayoutEngine.GetVerticalAlignment();
+  switch( verticalAlignment )
+  {
+    case LayoutEngine::VERTICAL_ALIGN_TOP:
+    {
+      mImpl->mAlignmentOffset.y = 0.f;
+      break;
+    }
+    case LayoutEngine::VERTICAL_ALIGN_CENTER:
+    {
+      const int intOffset = static_cast<int>( 0.5f * ( size.height - actualSize.height ) ); // try to avoid pixel alignment.
+      mImpl->mAlignmentOffset.y = static_cast<float>( intOffset );
+      break;
+    }
+    case LayoutEngine::VERTICAL_ALIGN_BOTTOM:
+    {
+      mImpl->mAlignmentOffset.y = size.height - actualSize.height;
+      break;
+    }
+  }
 }
 
 LayoutEngine& Controller::GetLayoutEngine()
@@ -1171,42 +1069,54 @@ 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 );
+
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      // Show alternative placeholder-text when editing
+      ShowPlaceholderText();
+    }
 
-    RequestRelayout();
+    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" );
 
-  if( mImpl->mTextInput &&
+  bool textChanged( false );
+
+  if( mImpl->mEventData &&
       keyEvent.state == KeyEvent::Down )
   {
     int keyCode = keyEvent.keyCode;
@@ -1223,69 +1133,465 @@ 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 );
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p DALI_KEY_BACKSPACE\n", this );
+
+      // IMF manager is no longer handling key-events
+      mImpl->ClearPreEditFlag();
+
+      // Remove the character before the current cursor position
+      bool removed = RemoveText( -1, 1 );
+
+      if( removed )
+      {
+        if( 0u == mImpl->mLogicalModel->mText.Count() )
+        {
+          ShowPlaceholderText();
+          mImpl->mEventData->mUpdateCursorPosition = true;
+        }
+        else
+        {
+          mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+        }
+
+        textChanged = true;
+      }
     }
-    else if( !keyString.empty() )
+    else
     {
-      // Queue an insert event
-      ModifyEvent event;
-      event.type = INSERT_TEXT;
-      event.text = keyString;
-      mImpl->mModifyEvents.push_back( event );
+      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;
     }
 
-    RequestRelayout();
+    mImpl->ChangeState( EventData::EDITING ); // todo Confirm this is the best place to change the state of
+
+    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 removedPreEdit( 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 );
+
+  if( ! text.empty() )
+  {
+    // The placeholder text is no longer needed
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      ResetText();
+    }
+
+    //  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() )
+  {
+    // Handle the IMF (predicitive text) state changes
+    if( mImpl->mEventData )
+    {
+      if( mImpl->mEventData->mPreEditFlag &&
+          0 != mImpl->mEventData->mPreEditLength )
+      {
+        // Remove previous pre-edit text
+        CharacterIndex offset = mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition;
+        removedPreEdit = RemoveText( -static_cast<int>(offset), mImpl->mEventData->mPreEditLength );
+
+        mImpl->mEventData->mPrimaryCursorPosition = mImpl->mEventData->mPreEditStartPosition;
+        mImpl->mEventData->mPreEditLength = 0;
+      }
+
+      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->GetNumberOfCharacters();
+
+    // 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( removedPreEdit ||
+      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();
+  }
+}
+
 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 );
+    if( 1u == tapCount )
+    {
+      bool tapDuringEditMode( EventData::EDITING == mImpl->mEventData->mState );
+
+      if( ! mImpl->IsShowingPlaceholderText() &&
+          EventData::EDITING == mImpl->mEventData->mState )
+      {
+        // Grab handle is not shown until a tap is received whilst EDITING
+        if( tapDuringEditMode )
+        {
+          mImpl->mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+        }
+        mImpl->mEventData->mDecorator->SetPopupActive( false );
+      }
+
+      mImpl->ChangeState( EventData::EDITING );
+    }
+    else if( mImpl->mEventData->mSelectionEnabled &&
+             ( 2u == tapCount ) )
+    {
+      mImpl->ChangeState( EventData::SELECTING );
+    }
+  }
+
+  // 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->mTextInput->mEventQueue.push_back( event );
+    mImpl->mEventData->mEventQueue.push_back( event );
 
-    RequestRelayout();
+    mImpl->RequestRelayout();
   }
+
+  // Reset keyboard as tap event has occurred.
+  mImpl->ResetImfManager();
 }
 
-void Controller::GrabHandleEvent( GrabHandleState state, float x, float y )
+void Controller::PanEvent( Gesture::State state, const Vector2& displacement )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected GrabHandleEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
 
-  if( mImpl->mTextInput )
+  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 );
+    Event event( Event::PAN_EVENT );
+    event.p1.mInt = state;
+    event.p2.mFloat = displacement.x;
+    event.p3.mFloat = displacement.y;
+    mImpl->mEventData->mEventQueue.push_back( event );
 
-    RequestRelayout();
+    mImpl->RequestRelayout();
   }
 }
 
+void Controller::GetTargetSize( Vector2& targetSize )
+{
+  targetSize = mImpl->mControlSize;
+}
+
+void Controller::AddDecoration( Actor& actor )
+{
+  mImpl->mControlInterface.AddDecoration( actor );
+}
+
+void Controller::DecorationEvent( HandleType handleType, HandleState state, float x, float y )
+{
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected DecorationEvent" );
+
+  if( mImpl->mEventData )
+  {
+    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;
+
+        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();
+  }
+}
+
+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;
 }
 
+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 )
 {