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=adf4e75f11ceef1068266a344cbe9b6916dca9d6;hp=995354c6bed93fc787aa220f2f386f5485446bfc;hb=8f97553fd7c63e1ae1625d560675201acf92c380;hpb=451d7a012c895c2578a29ba929dc61a6d959209a

diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp
index 995354c..adf4e75 100644
--- a/dali-toolkit/internal/text/text-controller.cpp
+++ b/dali-toolkit/internal/text/text-controller.cpp
@@ -18,24 +18,36 @@
 // CLASS HEADER
 #include <dali-toolkit/internal/text/text-controller.h>
 
+// EXTERNAL INCLUDES
+#include <limits>
+#include <iostream>
+#include <dali/public-api/adaptor-framework/key.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.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.h>
 
-// EXTERNAL INCLUDES
-#include <limits>
-#include <vector>
-#include <dali/public-api/text-abstraction/font-client.h>
+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();
 
-using std::vector;
+const std::string EMPTY_STRING("");
+
+} // namespace
 
 namespace Dali
 {
@@ -46,560 +58,886 @@ 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,
-    TAP_EVENT,
-    GRAB_HANDLE_EVENT
-  };
+  return ControllerPtr( new Controller( controlInterface ) );
+}
 
-  union Param
+void Controller::EnableTextInput( DecoratorPtr decorator )
+{
+  if( !mImpl->mEventData )
   {
-    int mInt;
-    unsigned int mUint;
-    float mFloat;
-  };
+    mImpl->mEventData = new EventData( decorator );
+  }
+}
+
+void Controller::SetText( const std::string& text )
+{
+  // Cancel previously queued inserts etc.
+  mImpl->mModifyEvents.clear();
+
+  // Remove the previously set text
+  ResetText();
 
-  struct Event
+  if( ! text.empty() )
   {
-    Event( EventType eventType )
-    : type( eventType )
+    //  Convert text into UTF-32
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
+    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 );
+
+    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() );
+
+    // Reset the cursor position
+    if( mImpl->mEventData )
     {
-      p1.mInt = 0;
-      p2.mInt = 0;
+      mImpl->mEventData->mPrimaryCursorPosition = characterCount;
     }
 
-    EventType type;
-    Param p1;
-    Param p2;
-    Param p3;
-  };
-
-  enum State
+    // Update the rest of the model during size negotiation
+    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
+  }
+  else
   {
-    INACTIVE,
-    SELECTING,
-    EDITING
-  };
+    ShowPlaceholderText();
+  }
 
-  TextInput( LogicalModelPtr logicalModel,
-             VisualModelPtr visualModel,
-             DecoratorPtr decorator )
-  : mLogicalModel( logicalModel ),
-    mVisualModel( visualModel ),
-    mDecorator( decorator ),
-    mState( INACTIVE )
+  if( mImpl->mEventData )
   {
+    // Cancel previously queued events
+    mImpl->mEventData->mEventQueue.clear();
   }
 
-  /**
-   * @brief Helper to move the cursor, grab handle etc.
-   */
-  bool ProcessTouchEvents()
+  // Reset keyboard as text changed
+  mImpl->ResetImfManager();
+}
+
+void Controller::GetText( std::string& text ) const
+{
+  if( ! mImpl->IsShowingPlaceholderText() )
   {
-    mDecoratorUpdated = false;
+    Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 
-    if( mDecorator )
+    if( 0u != utf32Characters.Count() )
     {
-      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 TAP_EVENT:
-          {
-            OnTapEvent( *iter );
-            break;
-          }
-          case GRAB_HANDLE_EVENT:
-          {
-            OnGrabHandleEvent( *iter );
-            break;
-          }
-        }
-      }
+      Utf32ToUtf8( &utf32Characters[0], utf32Characters.Count(), text );
     }
-
-    mEventQueue.clear();
-
-    return mDecoratorUpdated;
   }
+  else
+  {
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
+  }
+}
 
-  void OnKeyboardFocus( bool hasFocus )
+unsigned int Controller::GetLogicalCursorPosition() const
+{
+  if( mImpl->mEventData )
   {
-    // TODO
+    return mImpl->mEventData->mPrimaryCursorPosition;
   }
 
-  void OnTapEvent( const Event& event )
+  return 0u;
+}
+
+void Controller::SetPlaceholderText( PlaceholderType type, const std::string& text )
+{
+  if( mImpl->mEventData )
   {
-    if( 1u == event.p1.mUint )
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
+    {
+      mImpl->mEventData->mPlaceholderTextInactive = text;
+    }
+    else
     {
-      mState = TextInput::EDITING;
-      mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
-      mDecorator->StartCursorBlink();
-      mDecorator->SetGrabHandleActive( true );
+      mImpl->mEventData->mPlaceholderTextActive = text;
+    }
 
-      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 );
+    // Update placeholder if there is no text
+    if( mImpl->IsShowingPlaceholderText() ||
+        0u == mImpl->mLogicalModel->mText.Count() )
+    {
+      ShowPlaceholderText();
+    }
+  }
+}
 
-      mDecoratorUpdated = true;
+void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
+{
+  if( mImpl->mEventData )
+  {
+    if( PLACEHOLDER_TYPE_INACTIVE == type )
+    {
+      text = mImpl->mEventData->mPlaceholderTextInactive;
     }
-    else if( 2u == event.p1.mUint )
+    else
     {
-      mState = TextInput::SELECTING;
-      mDecorator->SetGrabHandleActive( false );
-      mDecorator->SetSelectionActive( true );
-      mDecoratorUpdated = true;
+      text = mImpl->mEventData->mPlaceholderTextActive;
     }
   }
+}
+
+void Controller::SetMaximumNumberOfCharacters( int maxCharacters )
+{
+  if ( maxCharacters >= 0 )
+  {
+    mImpl->mMaximumNumberOfCharacters = maxCharacters;
+  }
+}
+
+int Controller::GetMaximumNumberOfCharacters()
+{
+  return mImpl->mMaximumNumberOfCharacters;
+}
 
-  void OnGrabHandleEvent( const Event& event )
+void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
+{
+  if( !mImpl->mFontDefaults )
   {
-    unsigned int state = event.p1.mUint;
+    mImpl->mFontDefaults = new FontDefaults();
+  }
 
-    if( GRAB_HANDLE_PRESSED == state )
-    {
-      float xPosition = event.p2.mFloat;
-      float yPosition = event.p3.mFloat;
-      float height(0.0f);
+  mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
 
-      GetClosestCursorPosition( xPosition, yPosition, height );
+  // Clear the font-specific data
+  ClearFontData();
 
-      mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
-      mDecoratorUpdated = true;
-    }
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
+
+  mImpl->RequestRelayout();
+}
+
+const std::string& Controller::GetDefaultFontFamily() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultFontFamily;
   }
 
-  void GetClosestCursorPosition( float& x, float& y, float& height )
+  return EMPTY_STRING;
+}
+
+void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
+{
+  if( !mImpl->mFontDefaults )
   {
-    // TODO - Look at LineRuns first
+    mImpl->mFontDefaults = new FontDefaults();
+  }
 
-    Text::Length numberOfGlyphs = mVisualModel->GetNumberOfGlyphs();
-    if( 0 == numberOfGlyphs )
-    {
-      return;
-    }
+  mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
 
-    Vector<GlyphInfo> glyphs;
-    glyphs.Resize( numberOfGlyphs );
-    mVisualModel->GetGlyphs( &glyphs[0], 0, numberOfGlyphs );
+  // Clear the font-specific data
+  ClearFontData();
 
-    std::vector<Vector2> positions;
-    positions.resize( numberOfGlyphs );
-    mVisualModel->GetGlyphPositions( &positions[0], 0, numberOfGlyphs );
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
 
-    unsigned int closestGlyph = 0;
-    float closestDistance = std::numeric_limits<float>::max();
+  mImpl->RequestRelayout();
+}
 
-    for( unsigned int i=0; i<glyphs.Count(); ++i )
-    {
-      float glyphX = positions[i].x + glyphs[i].width*0.5f;
-      float glyphY = positions[i].y + glyphs[i].height*0.5f;
+const std::string& Controller::GetDefaultFontStyle() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultFontStyle;
+  }
 
-      float distanceToGlyph = fabsf( glyphX - x ) + fabsf( glyphY - y );
+  return EMPTY_STRING;
+}
 
-      if( distanceToGlyph < closestDistance )
-      {
-        closestDistance = distanceToGlyph;
-        closestGlyph = i;
-      }
-    }
+void Controller::SetDefaultPointSize( float pointSize )
+{
+  if( !mImpl->mFontDefaults )
+  {
+    mImpl->mFontDefaults = new FontDefaults();
+  }
+
+  mImpl->mFontDefaults->mDefaultPointSize = pointSize;
 
-    // TODO - Consider RTL languages
-    x = positions[closestGlyph].x + glyphs[closestGlyph].width;
-    y = 0.0f;
+  // Clear the font-specific data
+  ClearFontData();
 
-    FontMetrics metrics;
-    TextAbstraction::FontClient::Get().GetFontMetrics( glyphs[closestGlyph].fontId, metrics );
-    height = metrics.height; // TODO - Fix for multi-line
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+  mImpl->mRecalculateNaturalSize = true;
+
+  mImpl->RequestRelayout();
+}
+
+float Controller::GetDefaultPointSize() const
+{
+  if( mImpl->mFontDefaults )
+  {
+    return mImpl->mFontDefaults->mDefaultPointSize;
   }
 
-  LogicalModelPtr mLogicalModel;
-  VisualModelPtr  mVisualModel;
-  DecoratorPtr    mDecorator;
+  return 0.0f;
+}
 
-  State mState;
+void Controller::SetTextColor( const Vector4& textColor )
+{
+  mImpl->mTextColor = textColor;
 
-  /**
-   * 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.
+  if( ! mImpl->IsShowingPlaceholderText() )
+  {
+    mImpl->mVisualModel->SetTextColor( textColor );
+  }
+}
 
-  bool mDecoratorUpdated;
-};
+const Vector4& Controller::GetTextColor() const
+{
+  return mImpl->mTextColor;
+}
 
-struct Controller::Impl
+bool Controller::RemoveText( int cursorOffset, int numberOfChars )
 {
-  Impl( ControlInterface& controlInterface )
-  : mControlInterface( controlInterface ),
-    mNewText(),
-    mOperations( NO_OPERATION ),
-    mControlSize(),
-    mTextInput( NULL )
+  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() )
   {
-    mLogicalModel = LogicalModel::New();
-    mVisualModel  = VisualModel::New();
+    // 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;
+    }
+  }
 
-    mView.SetVisualModel( mVisualModel );
+  return removed;
+}
 
-    mFontClient = TextAbstraction::FontClient::Get();
+void Controller::SetPlaceholderTextColor( const Vector4& textColor )
+{
+  if( mImpl->mEventData )
+  {
+    mImpl->mEventData->mPlaceholderTextColor = textColor;
   }
 
-  ~Impl()
+  if( mImpl->IsShowingPlaceholderText() )
   {
-    delete mTextInput;
+    mImpl->mVisualModel->SetTextColor( textColor );
   }
+}
 
-  ControlInterface& mControlInterface;
+const Vector4& Controller::GetPlaceholderTextColor() const
+{
+  if( mImpl->mEventData )
+  {
+    return mImpl->mEventData->mPlaceholderTextColor;
+  }
+
+  return Color::BLACK;
+}
 
-  std::string mNewText;
+void Controller::SetShadowOffset( const Vector2& shadowOffset )
+{
+  mImpl->mVisualModel->SetShadowOffset( shadowOffset );
+}
+
+const Vector2& Controller::GetShadowOffset() const
+{
+  return mImpl->mVisualModel->GetShadowOffset();
+}
 
-  LogicalModelPtr mLogicalModel;
-  VisualModelPtr  mVisualModel;
+void Controller::SetShadowColor( const Vector4& shadowColor )
+{
+  mImpl->mVisualModel->SetShadowColor( shadowColor );
+}
 
-  View mView;
+const Vector4& Controller::GetShadowColor() const
+{
+  return mImpl->mVisualModel->GetShadowColor();
+}
 
-  LayoutEngine mLayoutEngine;
+void Controller::SetUnderlineColor( const Vector4& color )
+{
+  mImpl->mVisualModel->SetUnderlineColor( color );
+}
 
-  TextAbstraction::FontClient mFontClient;
+const Vector4& Controller::GetUnderlineColor() const
+{
+  return mImpl->mVisualModel->GetUnderlineColor();
+}
 
-  OperationsMask mOperations;
+void Controller::SetUnderlineEnabled( bool enabled )
+{
+  mImpl->mVisualModel->SetUnderlineEnabled( enabled );
+}
 
-  Size mControlSize;
+bool Controller::IsUnderlineEnabled() const
+{
+  return mImpl->mVisualModel->IsUnderlineEnabled();
+}
 
-  // Avoid allocating everything for text input until EnableTextInput()
-  Controller::TextInput* mTextInput;
-};
+void Controller::SetUnderlineHeight( float height )
+{
+  mImpl->mVisualModel->SetUnderlineHeight( height );
+}
 
-ControllerPtr Controller::New( ControlInterface& controlInterface )
+float Controller::GetUnderlineHeight() const
 {
-  return ControllerPtr( new Controller( controlInterface ) );
+  return mImpl->mVisualModel->GetUnderlineHeight();
 }
 
-void Controller::SetText( const std::string& text )
+void Controller::SetEnableCursorBlink( bool enable )
 {
-  // Keep until size negotiation
-  mImpl->mNewText = text;
-  mImpl->mOperations = ALL_OPERATIONS;
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "TextInput disabled" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData )
   {
-    // Cancel previously queued events
-    mImpl->mTextInput->mEventQueue.clear();
+    mImpl->mEventData->mCursorBlinkEnabled = enable;
+
+    if( !enable &&
+        mImpl->mEventData->mDecorator )
+    {
+      mImpl->mEventData->mDecorator->StopCursorBlink();
+    }
+  }
+}
+
+bool Controller::GetEnableCursorBlink() const
+{
+  if( mImpl->mEventData )
+  {
+    return mImpl->mEventData->mCursorBlinkEnabled;
+  }
+
+  return false;
+}
 
-    // TODO - Hide selection decorations
+const Vector2& Controller::GetScrollPosition() const
+{
+  if( mImpl->mEventData )
+  {
+    return mImpl->mEventData->mScrollPosition;
   }
+
+  return Vector2::ZERO;
+}
+
+const Vector2& Controller::GetAlignmentOffset() const
+{
+  return mImpl->mAlignmentOffset;
 }
 
-void Controller::GetText( std::string& text )
+Vector3 Controller::GetNaturalSize()
 {
-  if( !mImpl->mNewText.empty() )
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
+  Vector3 naturalSize;
+
+  // Make sure the model is up-to-date before layouting
+  ProcessModifyEvents();
+
+  if( mImpl->mRecalculateNaturalSize )
   {
-    text = mImpl->mNewText;
+    // Operations that can be done only once until the text changes.
+    const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
+                                                                           GET_SCRIPTS       |
+                                                                           VALIDATE_FONTS    |
+                                                                           GET_LINE_BREAKS   |
+                                                                           GET_WORD_BREAKS   |
+                                                                           BIDI_INFO         |
+                                                                           SHAPE_TEXT        |
+                                                                           GET_GLYPH_METRICS );
+    // Make sure the model is up-to-date before layouting
+    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 ),
+                static_cast<OperationsMask>( onlyOnceOperations |
+                                             sizeOperations ),
+                naturalSize.GetVectorXY() );
+
+    // Do not do again the only once operations.
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
+
+    // Do the size related operations again.
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
+
+    // Stores the natural size to avoid recalculate it again
+    // unless the text/style changes.
+    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
   {
-    // TODO - Convert from UTF-32
+    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;
 }
 
-void Controller::EnableTextInput( DecoratorPtr decorator )
+float Controller::GetHeightForWidth( float width )
 {
-  if( !mImpl->mTextInput )
+  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();
+
+  Size layoutSize;
+  if( width != mImpl->mControlSize.width )
+  {
+    // Operations that can be done only once until the text changes.
+    const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
+                                                                           GET_SCRIPTS       |
+                                                                           VALIDATE_FONTS    |
+                                                                           GET_LINE_BREAKS   |
+                                                                           GET_WORD_BREAKS   |
+                                                                           BIDI_INFO         |
+                                                                           SHAPE_TEXT        |
+                                                                           GET_GLYPH_METRICS );
+    // Make sure the model is up-to-date before layouting
+    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 ),
+                static_cast<OperationsMask>( onlyOnceOperations |
+                                             sizeOperations ),
+                layoutSize );
+
+    // Do not do again the only once operations.
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
+
+    // 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
   {
-    mImpl->mTextInput = new TextInput( mImpl->mLogicalModel, mImpl->mVisualModel, decorator );
+    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 );
+    if( 0u != mImpl->mVisualModel->GetNumberOfGlyphPositions() )
+    {
+      mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
+      glyphsRemoved = true;
+    }
     // Not worth to relayout if width or height is equal to zero.
-    return false;
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n" );
+    return glyphsRemoved;
   }
 
-  bool updated = false;
-
   if( size != mImpl->mControlSize )
   {
-    updated = DoRelayout( size, mImpl->mOperations );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mControlSize.width, mImpl->mControlSize.height );
 
-    // Do not re-do any operation until something changes.
-    mImpl->mOperations = NO_OPERATION;
+    // Operations that need to be done if the size changes.
+    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
+                                                             LAYOUT                    |
+                                                             ALIGN                     |
+                                                             UPDATE_ACTUAL_SIZE        |
+                                                             REORDER );
 
     mImpl->mControlSize = size;
   }
 
-  if( mImpl->mTextInput )
+  // Make sure the model is up-to-date before layouting
+  ProcessModifyEvents();
+  mImpl->UpdateModel( mImpl->mOperationsPending );
+
+  Size layoutSize;
+  bool updated = DoRelayout( mImpl->mControlSize,
+                             mImpl->mOperationsPending,
+                             layoutSize );
+
+  // Do not re-do any operation until something changes.
+  mImpl->mOperationsPending = NO_OPERATION;
+
+  // 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->ProcessTouchEvents() || updated;
+    updated = mImpl->ProcessInputEvents() || updated;
   }
 
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
   return updated;
 }
 
-bool Controller::DoRelayout( const Vector2& size, OperationsMask operations )
+void Controller::ProcessModifyEvents()
 {
-  bool viewUpdated( false );
+  std::vector<ModifyEvent>& events = mImpl->mModifyEvents;
 
-  Vector<Character> utf32Characters;
-  Length characterCount = 0u;
-  if( CONVERT_TO_UTF32 & operations )
+  for( unsigned int i=0; i<events.size(); ++i )
   {
-    std::string& text = mImpl->mNewText;
-
-    //  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 );
-
-    // Sets the text into the model.
-    mImpl->mLogicalModel->SetText( utf32Characters.Begin(), characterCount );
+    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 TEXT_REPLACED event" );
 
-    // Discard temporary text
-    //text.clear(); temporary keep the text. will be fixed in the next patch.
+      TextReplacedEvent();
+    }
+    else if( ModifyEvent::TEXT_INSERTED == events[0].type )
+    {
+      TextInsertedEvent();
+    }
+    else if( ModifyEvent::TEXT_DELETED == events[0].type )
+    {
+      // Placeholder-text cannot be deleted
+      if( !mImpl->IsShowingPlaceholderText() )
+      {
+        TextDeletedEvent();
+      }
+    }
   }
 
-  Vector<LineBreakInfo> lineBreakInfo;
-  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( characterCount, TextAbstraction::LINE_NO_BREAK );
+  // Discard temporary text
+  events.clear();
+}
 
-    SetLineBreakInfo( utf32Characters,
-                      lineBreakInfo );
+void Controller::ResetText()
+{
+  // Reset buffers.
+  mImpl->mLogicalModel->mText.Clear();
+  ClearModelData();
 
-    mImpl->mLogicalModel->SetLineBreakInfo( lineBreakInfo.Begin(), characterCount );
+  // Reset the cursor position
+  if( mImpl->mEventData )
+  {
+    mImpl->mEventData->mPrimaryCursorPosition = 0;
   }
 
-  Vector<WordBreakInfo> wordBreakInfo;
-  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( characterCount, TextAbstraction::WORD_NO_BREAK );
+  // We have cleared everything including the placeholder-text
+  mImpl->PlaceholderCleared();
 
-    SetWordBreakInfo( utf32Characters,
-                      wordBreakInfo );
+  // The natural size needs to be re-calculated.
+  mImpl->mRecalculateNaturalSize = true;
 
-    mImpl->mLogicalModel->SetWordBreakInfo( wordBreakInfo.Begin(), characterCount );
-  }
+  // Apply modifications to the model
+  mImpl->mOperationsPending = ALL_OPERATIONS;
+}
 
-  const bool getScripts = GET_SCRIPTS & operations;
-  const bool validateFonts = VALIDATE_FONTS & operations;
+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;
+  mImpl->UpdateModel( ALL_OPERATIONS );
+  mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
+                                                           ALIGN              |
+                                                           UPDATE_ACTUAL_SIZE |
+                                                           REORDER );
+}
 
-  Vector<ScriptRun> scripts;
-  Vector<FontRun> fonts;
-  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();
+void Controller::TextInsertedEvent()
+{
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextInsertedEvent" );
 
-    if( getScripts )
-    {
-      // Retrieves the scripts used in the text.
-      multilanguageSupport.SetScripts( utf32Characters,
-                                       lineBreakInfo,
-                                       scripts );
+  // TODO - Optimize this
+  ClearModelData();
 
-      // Sets the scripts into the model.
-      mImpl->mLogicalModel->SetScripts( scripts.Begin(), scripts.Count() );
-    }
+  // The natural size needs to be re-calculated.
+  mImpl->mRecalculateNaturalSize = true;
 
-    if( validateFonts )
-    {
-      // 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,
-                                          fonts );
+  // 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 );
 
-      // Sets the fonts into the model.
-      mImpl->mLogicalModel->SetFonts( fonts.Begin(), fonts.Count() );
-    }
-  }
+  // Queue a cursor reposition event; this must wait until after DoRelayout()
+  mImpl->mEventData->mUpdateCursorPosition = true;
+  mImpl->mEventData->mScrollAfterUpdateCursorPosition = true;
+}
 
-  Vector<GlyphInfo> glyphs;
-  Vector<CharacterIndex> glyphsToCharactersMap;
-  Vector<Length> charactersPerGlyph;
-  if( SHAPE_TEXT & operations )
-  {
-    // Shapes the text.
-    ShapeText( utf32Characters,
-               lineBreakInfo,
-               scripts,
-               fonts,
-               glyphs,
-               glyphsToCharactersMap,
-               charactersPerGlyph );
-  }
+void Controller::TextDeletedEvent()
+{
+  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextDeletedEvent" );
 
-  if( GET_GLYPH_METRICS & operations )
-  {
-    mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), glyphs.Count() );
-  }
+  // TODO - Optimize this
+  ClearModelData();
 
-  Length numberOfGlyphs = glyphs.Count();
-  if( 0u != numberOfGlyphs )
-  {
-    // Sets the glyphs into the model.
-    mImpl->mVisualModel->SetGlyphs( glyphs.Begin(),
-                                    glyphsToCharactersMap.Begin(),
-                                    charactersPerGlyph.Begin(),
-                                    numberOfGlyphs );
-  }
+  // The natural size needs to be re-calculated.
+  mImpl->mRecalculateNaturalSize = true;
 
-  if( LAYOUT & operations )
-  {
-    if( 0u == numberOfGlyphs )
-    {
-      const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
-      numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
+  // 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 );
 
-      lineBreakInfo.Resize( numberOfCharacters );
-      wordBreakInfo.Resize( numberOfCharacters );
-      glyphs.Resize( numberOfGlyphs );
-      glyphsToCharactersMap.Resize( numberOfGlyphs );
-      charactersPerGlyph.Resize( numberOfGlyphs );
+  // Queue a cursor reposition event; this must wait until after DoRelayout()
+  mImpl->mEventData->mUpdateCursorPosition = true;
+  mImpl->mEventData->mScrollAfterUpdateCursorPosition = true;
+}
 
-      mImpl->mLogicalModel->GetLineBreakInfo( lineBreakInfo.Begin(),
-                                              0u,
-                                              numberOfCharacters );
+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 );
 
-      mImpl->mLogicalModel->GetWordBreakInfo( wordBreakInfo.Begin(),
-                                              0u,
-                                              numberOfCharacters );
+  // Calculate the operations to be done.
+  const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
 
-      mImpl->mVisualModel->GetGlyphs( glyphs.Begin(),
-                                      0u,
-                                      numberOfGlyphs );
+  if( LAYOUT & operations )
+  {
+    // Some vectors with data needed to layout and reorder may be void
+    // after the first time the text has been laid out.
+    // Fill the vectors again.
 
-      mImpl->mVisualModel->GetGlyphToCharacterMap( glyphsToCharactersMap.Begin(),
-                                                   0u,
-                                                   numberOfGlyphs );
+    Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
 
-      mImpl->mVisualModel->GetCharactersPerGlyphMap( charactersPerGlyph.Begin(),
-                                                     0u,
-                                                     numberOfGlyphs );
+    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(),
                                        charactersPerGlyph.Begin() );
 
-    // Reserve space to set the positions of the glyphs.
-    Vector<Vector2> glyphPositions;
-    glyphPositions.Resize( numberOfGlyphs );
+    // The laid-out lines.
+    // It's not possible to know in how many lines the text is going to be laid-out,
+    // but it can be resized at least with the number of 'paragraphs' to avoid
+    // some re-allocations.
+    Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
 
-    Size layoutSize;
+    // Delete any previous laid out lines before setting the new ones.
+    lines.Clear();
 
-    // Update the visual model
+    // 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 );
+
+    // Update the visual model.
     viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
                                                    glyphPositions,
+                                                   lines,
                                                    layoutSize );
 
-    // Sets the positions into the model.
-    mImpl->mVisualModel->SetGlyphPositions( glyphPositions.Begin(),
-                                            numberOfGlyphs );
+    if( viewUpdated )
+    {
+      // Reorder the lines
+      if( REORDER & operations )
+      {
+        Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
+
+        // Check first if there are paragraphs with bidirectional info.
+        if( 0u != bidirectionalInfo.Count() )
+        {
+          // Get the lines
+          const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
+
+          // Reorder the lines.
+          Vector<BidirectionalLineInfoRun> lineBidirectionalInfoRuns;
+          lineBidirectionalInfoRuns.Reserve( numberOfLines ); // Reserve because is not known yet how many lines have right to left characters.
+          ReorderLines( bidirectionalInfo,
+                        lines,
+                        lineBidirectionalInfoRuns );
+
+          // Set the bidirectional info into the model.
+          const Length numberOfBidirectionalInfoRuns = lineBidirectionalInfoRuns.Count();
+          mImpl->mLogicalModel->SetVisualToLogicalMap( lineBidirectionalInfoRuns.Begin(),
+                                                       numberOfBidirectionalInfoRuns );
+
+          // Set the bidirectional info per line into the layout parameters.
+          layoutParameters.lineBidirectionalInfoRunsBuffer = lineBidirectionalInfoRuns.Begin();
+          layoutParameters.numberOfBidirectionalInfoRuns = numberOfBidirectionalInfoRuns;
+
+          // Get the character to glyph conversion table and set into the layout.
+          layoutParameters.charactersToGlyphsBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
+
+          // Get the glyphs per character table and set into the layout.
+          layoutParameters.glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
+
+          // Re-layout the text. Reorder those lines with right to left characters.
+          mImpl->mLayoutEngine.ReLayoutRightToLeftLines( layoutParameters,
+                                                         glyphPositions );
+
+          // Free the allocated memory used to store the conversion table in the bidirectional line info run.
+          for( Vector<BidirectionalLineInfoRun>::Iterator it = lineBidirectionalInfoRuns.Begin(),
+                 endIt = lineBidirectionalInfoRuns.End();
+               it != endIt;
+               ++it )
+          {
+            BidirectionalLineInfoRun& bidiLineInfo = *it;
+
+            free( bidiLineInfo.visualToLogicalMap );
+          }
+        }
+      } // REORDER
 
-    // Sets the actual size.
-    mImpl->mVisualModel->SetActualSize( layoutSize );
+      if( ALIGN & operations )
+      {
+        mImpl->mLayoutEngine.Align( layoutParameters,
+                                    layoutSize,
+                                    lines,
+                                    glyphPositions );
+      }
+
+      // Sets the actual size.
+      if( UPDATE_ACTUAL_SIZE & operations )
+      {
+        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;
 }
 
-Vector3 Controller::GetNaturalSize()
+void Controller::CalculateTextAlignment( const Size& size )
 {
-  // TODO - Finish implementing
-  return Vector3::ZERO;
+  // Get the direction of the first character.
+  const CharacterDirection firstParagraphDirection = mImpl->mLogicalModel->GetCharacterDirection( 0u );
 
-  // Operations that can be done only once until the text changes.
-  const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32 |
-                                                                         GET_SCRIPTS      |
-                                                                         VALIDATE_FONTS   |
-                                                                         GET_LINE_BREAKS  |
-                                                                         GET_WORD_BREAKS  |
-                                                                         SHAPE_TEXT       |
-                                                                         GET_GLYPH_METRICS );
+  const Size& actualSize = mImpl->mVisualModel->GetActualSize();
 
-  // Operations that need to be done if the size or the text changes.
-  const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
-                                                                      REORDER );
-
-  const float maxFloat = std::numeric_limits<float>::max();
-  DoRelayout( Vector2( maxFloat, maxFloat ),
-              static_cast<OperationsMask>( onlyOnceOperations |
-                                           sizeOperations ) );
-
-  // Do not do again the only once operations.
-  mImpl->mOperations = static_cast<OperationsMask>( mImpl->mOperations & ~onlyOnceOperations );
+  // 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;
+    }
+  }
 
-  // Do the size related operations again.
-  mImpl->mOperations = static_cast<OperationsMask>( mImpl->mOperations | sizeOperations );
+  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;
+    }
+  }
 
-  return Vector3( mImpl->mVisualModel->GetNaturalSize() );
+  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;
+    }
+  }
 }
 
-float Controller::GetHeightForWidth( float width )
+LayoutEngine& Controller::GetLayoutEngine()
 {
-  // Operations that can be done only once until the text changes.
-  const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32 |
-                                                                         GET_SCRIPTS      |
-                                                                         VALIDATE_FONTS   |
-                                                                         GET_LINE_BREAKS  |
-                                                                         GET_WORD_BREAKS  |
-                                                                         SHAPE_TEXT       |
-                                                                         GET_GLYPH_METRICS );
-
-  // Operations that need to be done if the size or the text changes.
-  const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
-                                                                      REORDER );
-
-  DoRelayout( Size( width, 0.f ),
-              static_cast<OperationsMask>( onlyOnceOperations |
-                                           sizeOperations ) );
-
-  // Do not do again the only once operations.
-  mImpl->mOperations = static_cast<OperationsMask>( mImpl->mOperations & ~onlyOnceOperations );
-
-  // Do the size related operations again.
-  mImpl->mOperations = static_cast<OperationsMask>( mImpl->mOperations | sizeOperations );
-
-  return mImpl->mVisualModel->GetActualSize().height;
+  return mImpl->mLayoutEngine;
 }
 
 View& Controller::GetView()
@@ -607,71 +945,331 @@ View& Controller::GetView()
   return mImpl->mView;
 }
 
-LayoutEngine& Controller::GetLayoutEngine()
+void Controller::KeyboardFocusGainEvent()
 {
-  return mImpl->mLayoutEngine;
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
+
+  if( mImpl->mEventData )
+  {
+    mImpl->ChangeState( EventData::EDITING );
+
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      // Show alternative placeholder-text when editing
+      ShowPlaceholderText();
+    }
+
+    mImpl->RequestRelayout();
+  }
 }
 
-void Controller::RequestRelayout()
+void Controller::KeyboardFocusLostEvent()
 {
-  mImpl->mControlInterface.RequestTextRelayout();
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
+
+  if( mImpl->mEventData )
+  {
+    mImpl->ChangeState( EventData::INACTIVE );
+
+    if( mImpl->IsShowingPlaceholderText() )
+    {
+      // Revert to regular placeholder-text when not editing
+      ShowPlaceholderText();
+    }
+
+    mImpl->RequestRelayout();
+  }
 }
 
-void Controller::KeyboardFocusGainEvent()
+bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusGainEvent" );
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyEvent" );
 
-  if( mImpl->mTextInput )
+  if( mImpl->mEventData &&
+      keyEvent.state == KeyEvent::Down )
   {
-    TextInput::Event event( TextInput::KEYBOARD_FOCUS_GAIN_EVENT );
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    int keyCode = keyEvent.keyCode;
+    const std::string& keyString = keyEvent.keyPressed;
+
+    // Pre-process to separate modifying events from non-modifying input events.
+    if( Dali::DALI_KEY_ESCAPE == keyCode )
+    {
+      // Escape key is a special case which causes focus loss
+      KeyboardFocusLostEvent();
+    }
+    else if( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ||
+             Dali::DALI_KEY_CURSOR_RIGHT == keyCode ||
+             Dali::DALI_KEY_CURSOR_UP    == keyCode ||
+             Dali::DALI_KEY_CURSOR_DOWN  == keyCode )
+    {
+      Event event( Event::CURSOR_KEY_EVENT );
+      event.p1.mInt = keyCode;
+      mImpl->mEventData->mEventQueue.push_back( event );
+    }
+    else if( Dali::DALI_KEY_BACKSPACE == keyCode )
+    {
+      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 );
+        }
+      }
+    }
+    else
+    {
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", this, keyString.c_str() );
 
-    RequestRelayout();
+      // IMF manager is no longer handling key-events
+      mImpl->ClearPreEditFlag();
+
+      InsertText( keyString, COMMIT );
+    }
+
+    mImpl->ChangeState( EventData::EDITING ); // todo Confirm this is the best place to change the state of
+
+    mImpl->RequestRelayout();
   }
+
+  return false;
 }
 
-void Controller::KeyboardFocusLostEvent()
+void Controller::InsertText( const std::string& text, Controller::InsertType type )
 {
-  DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusLostEvent" );
+  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 );
 
-  if( mImpl->mTextInput )
+  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 )
   {
-    TextInput::Event event( TextInput::KEYBOARD_FOCUS_LOST_EVENT );
-    mImpl->mTextInput->mEventQueue.push_back( event );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mLogicalModel->mText.Count() );
 
-    RequestRelayout();
+    mImpl->mControlInterface.MaxLengthReached();
+
+    mImpl->ResetImfManager();
   }
 }
 
 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 );
+
+    mImpl->RequestRelayout();
+  }
+}
+
+void Controller::HandleEvent( HandleType handleType, HandleState state, float x, float y )
+{
+  DALI_ASSERT_DEBUG( mImpl->mEventData && "Controller::HandleEvent. Unexpected HandleEvent" );
+
+  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;
 
-    RequestRelayout();
+        mImpl->mEventData->mEventQueue.push_back( event );
+        break;
+      }
+      case HANDLE_TYPE_COUNT:
+      {
+        DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
+      }
+    }
+
+    mImpl->RequestRelayout();
   }
 }
 
@@ -680,6 +1278,103 @@ Controller::~Controller()
   delete mImpl;
 }
 
+void Controller::ShowPlaceholderText()
+{
+  if( mImpl->IsPlaceholderAvailable() )
+  {
+    DALI_ASSERT_DEBUG( mImpl->mEventData && "No placeholder text available" );
+
+    mImpl->mEventData->mIsShowingPlaceholderText = true;
+
+    // Cancel previously queued inserts etc.
+    mImpl->mModifyEvents.clear();
+
+    // 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;
+    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 )
 {