[Tizen] Add parameter (bool immediate) to TextChanged signal in interface

virtual void TextChanged(bool immediate) = 0;
using immediate, can decide whether we only emit the signal when OnRelayout() is called next time,
otherwise emits it immediately.

* there is a issue that the timing of callback calls has been delayed
due to a recent patch that limits unnecessary callbacks.
(33ccee79d16a90d5f7ab427de1503ccc5bee4324)

Because of this, there is a problem that the TC like example below fails.
This patch can prevents the following issues.

/* example */

bool textChanged;

...

static void OnTextChanged(TextField control)
{
  textChanged = true;
}

...

field.TextChangedSignal().Connect(&OnTextChanged);
textChanged = false;
field.SetProperty(TextField::Property::TEXT, "hello");
DALI_TEST_CHECK(textChanged); // At this point, textChanged is false, so TC Fail occurs.

/* example */

Change-Id: If0a331c56f35eae931b34d128b4fe4282fc686b6
Signed-off-by: Bowon Ryu <bowon.ryu@samsung.com>

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp b/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
index d688e2c..dc1d9ac 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
@@ -957,17 +957,14 @@ int utcDaliTextEditorTextChangedP(void)
 
   gTextChangedCallBackCalled = false;
   editor.SetProperty( TextEditor::Property::TEXT, "ABC" );
-  application.SendNotification();
-  application.Render();
   DALI_TEST_CHECK( gTextChangedCallBackCalled );
   DALI_TEST_CHECK( textChangedSignal );
 
+  application.SendNotification();
   editor.SetKeyInputFocus();
 
   gTextChangedCallBackCalled = false;
   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
-  application.SendNotification();
-  application.Render();
   DALI_TEST_CHECK( gTextChangedCallBackCalled );
 
   END_TEST;

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp b/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
index efcaacb..9d65f2e 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
@@ -1028,18 +1028,86 @@ int utcDaliTextFieldTextChangedP(void)
 
   gTextChangedCallBackCalled = false;
   field.SetProperty( TextField::Property::TEXT, "ABC" );
-  application.SendNotification();
-  application.Render();
   DALI_TEST_CHECK( gTextChangedCallBackCalled );
   DALI_TEST_CHECK( textChangedSignal );
 
+  application.SendNotification();
   field.SetKeyInputFocus();
 
   gTextChangedCallBackCalled = false;
   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
+  DALI_TEST_CHECK( gTextChangedCallBackCalled );
+
+  END_TEST;
+}
+
+int utcDaliTextFieldTextChangedWithInputMethodContext(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" utcDaliTextFieldTextChangedWithInputMethodContext");
+  TextField field = TextField::New();
+  DALI_TEST_CHECK( field );
+
+
+  application.GetScene().Add( field );
+
+  // connect to the text changed signal.
+  ConnectionTracker* testTracker = new ConnectionTracker();
+  field.TextChangedSignal().Connect(&TestTextChangedCallback);
+  bool textChangedSignal = false;
+  field.ConnectSignal( testTracker, "textChanged",   CallbackFunctor(&textChangedSignal) );
+
+
+  // get InputMethodContext
+  std::string text;
+  InputMethodContext::EventData imfEvent;
+  InputMethodContext inputMethodContext = DevelTextField::GetInputMethodContext( field );
+
+  field.SetKeyInputFocus();
+  field.SetProperty( DevelTextField::Property::ENABLE_EDITING, true );
+
+  // input text
+  gTextChangedCallBackCalled = false;
+  imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "ㅎ", 0, 1 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  application.SendNotification();
+  application.Render();
+  DALI_TEST_CHECK( gTextChangedCallBackCalled );
+  DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("ㅎ"), TEST_LOCATION );
+
+  gTextChangedCallBackCalled = false;
+  imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "호", 0, 1 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  application.SendNotification();
+  application.Render();
+  DALI_TEST_CHECK( gTextChangedCallBackCalled );
+  DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("호"), TEST_LOCATION );
+
+  gTextChangedCallBackCalled = false;
+  imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "혿", 0, 1 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  application.SendNotification();
+  application.Render();
+  DALI_TEST_CHECK( gTextChangedCallBackCalled );
+  DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("혿"), TEST_LOCATION );
+
+  gTextChangedCallBackCalled = false;
+  imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "", 0, 1 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  DALI_TEST_CHECK( !gTextChangedCallBackCalled );
+
+  imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "호", 0, 1 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  DALI_TEST_CHECK( !gTextChangedCallBackCalled );
+
+  imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "두", 1, 2 );
+  inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
+  DALI_TEST_CHECK( !gTextChangedCallBackCalled );
+
   application.SendNotification();
   application.Render();
   DALI_TEST_CHECK( gTextChangedCallBackCalled );
+  DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("호두"), TEST_LOCATION );
 
   END_TEST;
 }

diff --git a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
index e216301..c40674a 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
+++ b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
@@ -1332,9 +1332,7 @@ void TextEditor::OnRelayout(const Vector2& size, RelayoutContainer& container)
     // If there is text changed, callback is called.
     if(mTextChanged)
     {
-      Dali::Toolkit::TextEditor handle(GetOwner());
-      mTextChangedSignal.Emit(handle);
-      mTextChanged = false;
+      EmitTextChangedSignal();
     }
   }
 
@@ -1516,9 +1514,23 @@ void TextEditor::RequestTextRelayout()
   RelayoutRequest();
 }
 
-void TextEditor::TextChanged()
+void TextEditor::TextChanged(bool immediate)
 {
-  mTextChanged = true;
+  if(immediate) // Emits TextChangedSignal immediately
+  {
+    EmitTextChangedSignal();
+  }
+  else
+  {
+    mTextChanged = true;
+  }
+}
+
+void TextEditor::EmitTextChangedSignal()
+{
+  Dali::Toolkit::TextEditor handle(GetOwner());
+  mTextChangedSignal.Emit(handle);
+  mTextChanged = false;
 }
 
 void TextEditor::MaxLengthReached()

diff --git a/dali-toolkit/internal/controls/text-controls/text-editor-impl.h b/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
index 102600d..8ebda42 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
+++ b/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
@@ -182,7 +182,7 @@ private: // From Control
   /**
    * @copydoc Text::EditableControlInterface::TextChanged()
    */
-  void TextChanged() override;
+  void TextChanged(bool immediate) override;
 
   /**
    * @copydoc Text::EditableControlInterface::MaxLengthReached()
@@ -286,6 +286,11 @@ private: // Implementation
   void OnIdleSignal();
 
   /**
+   * @brief Emits TextChanged signal.
+   */
+  void EmitTextChangedSignal();
+
+  /**
    * @brief set RenderActor's position with new scrollPosition
    *
    * Apply updated scroll position or start scroll animation if VerticalScrollAnimation is enabled
@@ -351,7 +356,7 @@ private: // Data
   bool  mScrollAnimationEnabled : 1;
   bool  mScrollBarEnabled : 1;
   bool  mScrollStarted : 1;
-  bool  mTextChanged : 1;
+  bool  mTextChanged : 1; ///< If true, emits TextChangedSignal in next OnRelayout().
 };
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
index dccd577..95ae857 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
+++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
@@ -1350,9 +1350,7 @@ void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
     // If there is text changed, callback is called.
     if(mTextChanged)
     {
-      Dali::Toolkit::TextField handle(GetOwner());
-      mTextChangedSignal.Emit(handle);
-      mTextChanged = false;
+      EmitTextChangedSignal();
     }
   }
 
@@ -1623,9 +1621,23 @@ void TextField::SetEditable(bool editable)
   }
 }
 
-void TextField::TextChanged()
+void TextField::TextChanged(bool immediate)
 {
-  mTextChanged = true;
+  if(immediate) // Emits TextChangedSignal immediately
+  {
+    EmitTextChangedSignal();
+  }
+  else
+  {
+    mTextChanged = true;
+  }
+}
+
+void TextField::EmitTextChangedSignal()
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mTextChangedSignal.Emit(handle);
+  mTextChanged = false;
 }
 
 void TextField::MaxLengthReached()

diff --git a/dali-toolkit/internal/controls/text-controls/text-field-impl.h b/dali-toolkit/internal/controls/text-controls/text-field-impl.h
index 4ed876e..b5fc8a4 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-field-impl.h
+++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.h
@@ -174,7 +174,7 @@ private: // From Control
   /**
    * @copydoc Text::EditableControlInterface::TextChanged()
    */
-  void TextChanged() override;
+  void TextChanged(bool immediate) override;
 
   /**
    * @copydoc Text::EditableControlInterface::MaxLengthReached()
@@ -276,6 +276,11 @@ private: // Implementation
   void OnIdleSignal();
 
   /**
+   * @brief Emits TextChanged signal.
+   */
+  void EmitTextChangedSignal();
+
+  /**
    * Construct a new TextField.
    */
   TextField();
@@ -327,7 +332,7 @@ private: // Data
   int   mRenderingBackend;
   int   mExceedPolicy;
   bool  mHasBeenStaged : 1;
-  bool  mTextChanged : 1;
+  bool  mTextChanged : 1; ///< If true, emits TextChangedSignal in next OnRelayout().
 };
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/text/text-controller-event-handler.cpp b/dali-toolkit/internal/text/text-controller-event-handler.cpp
index 89ff0f9..11f8b12 100644 (file)
--- a/dali-toolkit/internal/text/text-controller-event-handler.cpp
+++ b/dali-toolkit/internal/text/text-controller-event-handler.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,9 +19,9 @@
 #include <dali-toolkit/internal/text/text-controller-event-handler.h>
 
 // EXTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
 #include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
 #include <dali/devel-api/adaptor-framework/key-devel.h>
+#include <dali/integration-api/debug.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/internal/text/text-controller-impl.h>
@@ -29,44 +29,40 @@
 
 namespace
 {
-
 #if defined(DEBUG_ENABLED)
 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
 #endif
 
-const std::string KEY_C_NAME = "c";
-const std::string KEY_V_NAME = "v";
-const std::string KEY_X_NAME = "x";
-const std::string KEY_A_NAME = "a";
+const std::string KEY_C_NAME      = "c";
+const std::string KEY_V_NAME      = "v";
+const std::string KEY_X_NAME      = "x";
+const std::string KEY_A_NAME      = "a";
 const std::string KEY_INSERT_NAME = "Insert";
 
 } // namespace
 
 namespace Dali
 {
-
 namespace Toolkit
 {
-
 namespace Text
 {
-
 void Controller::EventHandler::KeyboardFocusGainEvent(Controller& controller)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected KeyboardFocusGainEvent");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    if( ( EventData::INACTIVE == controller.mImpl->mEventData->mState ) ||
-        ( EventData::INTERRUPTED == controller.mImpl->mEventData->mState ) )
+    if((EventData::INACTIVE == controller.mImpl->mEventData->mState) ||
+       (EventData::INTERRUPTED == controller.mImpl->mEventData->mState))
     {
-      controller.mImpl->ChangeState( EventData::EDITING );
-      controller.mImpl->mEventData->mUpdateCursorPosition = true; //If editing started without tap event, cursor update must be triggered.
-      controller.mImpl->mEventData->mUpdateInputStyle = true;
+      controller.mImpl->ChangeState(EventData::EDITING);
+      controller.mImpl->mEventData->mUpdateCursorPosition      = true; //If editing started without tap event, cursor update must be triggered.
+      controller.mImpl->mEventData->mUpdateInputStyle          = true;
       controller.mImpl->mEventData->mScrollAfterUpdatePosition = true;
     }
     controller.mImpl->NotifyInputMethodContextMultiLineStatus();
-    if( controller.mImpl->IsShowingPlaceholderText() )
+    if(controller.mImpl->IsShowingPlaceholderText())
     {
       // Show alternative placeholder-text when editing
       controller.ShowPlaceholderText();
@@ -78,15 +74,15 @@ void Controller::EventHandler::KeyboardFocusGainEvent(Controller& controller)
 
 void Controller::EventHandler::KeyboardFocusLostEvent(Controller& controller)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected KeyboardFocusLostEvent");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    if( EventData::INTERRUPTED != controller.mImpl->mEventData->mState )
+    if(EventData::INTERRUPTED != controller.mImpl->mEventData->mState)
     {
-      controller.mImpl->ChangeState( EventData::INACTIVE );
+      controller.mImpl->ChangeState(EventData::INACTIVE);
 
-      if( !controller.mImpl->IsShowingRealText() )
+      if(!controller.mImpl->IsShowingRealText())
       {
         // Revert to regular placeholder-text when not editing
         controller.ShowPlaceholderText();
@@ -98,83 +94,83 @@ void Controller::EventHandler::KeyboardFocusLostEvent(Controller& controller)
 
 bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyEvent& keyEvent)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected KeyEvent");
 
-  bool textChanged = false;
+  bool textChanged    = false;
   bool relayoutNeeded = false;
 
-  if( ( NULL != controller.mImpl->mEventData ) &&
-      ( keyEvent.GetState() == KeyEvent::DOWN ) )
+  if((NULL != controller.mImpl->mEventData) &&
+     (keyEvent.GetState() == KeyEvent::DOWN))
   {
-    int keyCode = keyEvent.GetKeyCode();
+    int                keyCode   = keyEvent.GetKeyCode();
     const std::string& keyString = keyEvent.GetKeyString();
-    const std::string keyName = keyEvent.GetKeyName();
+    const std::string  keyName   = keyEvent.GetKeyName();
     // Key will produce same logical-key value when ctrl
     // is down, regardless of language layout
     const std::string logicalKey = keyEvent.GetLogicalKey();
 
-    const bool isNullKey = ( 0 == keyCode ) && ( keyString.empty() );
+    const bool isNullKey = (0 == keyCode) && (keyString.empty());
 
     // Pre-process to separate modifying events from non-modifying input events.
-    if( isNullKey )
+    if(isNullKey)
     {
       // In some platforms arrive key events with no key code.
       // Do nothing.
       return false;
     }
-    else if( Dali::DALI_KEY_ESCAPE == keyCode || Dali::DALI_KEY_BACK == keyCode  || Dali::DALI_KEY_SEARCH == keyCode )
+    else if(Dali::DALI_KEY_ESCAPE == keyCode || Dali::DALI_KEY_BACK == keyCode || Dali::DALI_KEY_SEARCH == keyCode)
     {
       // Do nothing
       return false;
     }
-    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 ) )
+    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))
     {
       // If don't have any text, do nothing.
-      if( !controller.mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters )
+      if(!controller.mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters)
       {
         return false;
       }
 
-      uint32_t cursorPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
+      uint32_t cursorPosition     = controller.mImpl->mEventData->mPrimaryCursorPosition;
       uint32_t numberOfCharacters = controller.mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-      uint32_t cursorLine = controller.mImpl->mModel->mVisualModel->GetLineOfCharacter( cursorPosition );
-      uint32_t numberOfLines = controller.mImpl->mModel->GetNumberOfLines();
+      uint32_t cursorLine         = controller.mImpl->mModel->mVisualModel->GetLineOfCharacter(cursorPosition);
+      uint32_t numberOfLines      = controller.mImpl->mModel->GetNumberOfLines();
 
       // Logic to determine whether this text control will lose focus or not.
-      if( ( Dali::DALI_KEY_CURSOR_LEFT == keyCode && 0 == cursorPosition && !keyEvent.IsShiftModifier() ) ||
-          ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode && numberOfCharacters == cursorPosition && !keyEvent.IsShiftModifier() ) ||
-          ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && cursorLine == numberOfLines -1 ) ||
-          ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && numberOfCharacters == cursorPosition && cursorLine -1 == numberOfLines -1 ) ||
-          ( Dali::DALI_KEY_CURSOR_UP == keyCode && cursorLine == 0 ) ||
-          ( Dali::DALI_KEY_CURSOR_UP == keyCode && numberOfCharacters == cursorPosition && cursorLine == 1 ) )
+      if((Dali::DALI_KEY_CURSOR_LEFT == keyCode && 0 == cursorPosition && !keyEvent.IsShiftModifier()) ||
+         (Dali::DALI_KEY_CURSOR_RIGHT == keyCode && numberOfCharacters == cursorPosition && !keyEvent.IsShiftModifier()) ||
+         (Dali::DALI_KEY_CURSOR_DOWN == keyCode && cursorLine == numberOfLines - 1) ||
+         (Dali::DALI_KEY_CURSOR_DOWN == keyCode && numberOfCharacters == cursorPosition && cursorLine - 1 == numberOfLines - 1) ||
+         (Dali::DALI_KEY_CURSOR_UP == keyCode && cursorLine == 0) ||
+         (Dali::DALI_KEY_CURSOR_UP == keyCode && numberOfCharacters == cursorPosition && cursorLine == 1))
       {
         // Release the active highlight.
-        if( controller.mImpl->mEventData->mState == EventData::SELECTING )
+        if(controller.mImpl->mEventData->mState == EventData::SELECTING)
         {
-          controller.mImpl->ChangeState( EventData::EDITING );
+          controller.mImpl->ChangeState(EventData::EDITING);
 
           // Update selection position.
-          controller.mImpl->mEventData->mLeftSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
+          controller.mImpl->mEventData->mLeftSelectionPosition  = controller.mImpl->mEventData->mPrimaryCursorPosition;
           controller.mImpl->mEventData->mRightSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
-          controller.mImpl->mEventData->mUpdateCursorPosition = true;
+          controller.mImpl->mEventData->mUpdateCursorPosition   = true;
           controller.mImpl->RequestRelayout();
         }
         return false;
       }
 
       controller.mImpl->mEventData->mCheckScrollAmount = true;
-      Event event( Event::CURSOR_KEY_EVENT );
-      event.p1.mInt = keyCode;
+      Event event(Event::CURSOR_KEY_EVENT);
+      event.p1.mInt  = keyCode;
       event.p2.mBool = keyEvent.IsShiftModifier();
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
 
       // Will request for relayout.
       relayoutNeeded = true;
     }
-    else if ( Dali::DevelKey::DALI_KEY_CONTROL_LEFT == keyCode || Dali::DevelKey::DALI_KEY_CONTROL_RIGHT == keyCode )
+    else if(Dali::DevelKey::DALI_KEY_CONTROL_LEFT == keyCode || Dali::DevelKey::DALI_KEY_CONTROL_RIGHT == keyCode)
     {
       // Left or Right Control key event is received before Ctrl-C/V/X key event is received
       // If not handle it here, any selected text will be deleted
@@ -182,56 +178,56 @@ bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyE
       // Do nothing
       return false;
     }
-    else if ( keyEvent.IsCtrlModifier() && !keyEvent.IsShiftModifier())
+    else if(keyEvent.IsCtrlModifier() && !keyEvent.IsShiftModifier())
     {
       bool consumed = false;
-      if (keyName == KEY_C_NAME || keyName == KEY_INSERT_NAME || logicalKey == KEY_C_NAME || logicalKey == KEY_INSERT_NAME)
+      if(keyName == KEY_C_NAME || keyName == KEY_INSERT_NAME || logicalKey == KEY_C_NAME || logicalKey == KEY_INSERT_NAME)
       {
         // Ctrl-C or Ctrl+Insert to copy the selected text
-        controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::COPY );
+        controller.TextPopupButtonTouched(Toolkit::TextSelectionPopup::COPY);
         consumed = true;
       }
-      else if (keyName == KEY_V_NAME || logicalKey == KEY_V_NAME)
+      else if(keyName == KEY_V_NAME || logicalKey == KEY_V_NAME)
       {
         // Ctrl-V to paste the copied text
-        controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::PASTE );
+        controller.TextPopupButtonTouched(Toolkit::TextSelectionPopup::PASTE);
         consumed = true;
       }
-      else if (keyName == KEY_X_NAME || logicalKey == KEY_X_NAME)
+      else if(keyName == KEY_X_NAME || logicalKey == KEY_X_NAME)
       {
         // Ctrl-X to cut the selected text
-        controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT );
+        controller.TextPopupButtonTouched(Toolkit::TextSelectionPopup::CUT);
         consumed = true;
       }
-      else if (keyName == KEY_A_NAME || logicalKey == KEY_A_NAME)
+      else if(keyName == KEY_A_NAME || logicalKey == KEY_A_NAME)
       {
         // Ctrl-A to select All the text
-        controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::SELECT_ALL );
+        controller.TextPopupButtonTouched(Toolkit::TextSelectionPopup::SELECT_ALL);
         consumed = true;
       }
       return consumed;
     }
-    else if( ( Dali::DALI_KEY_BACKSPACE == keyCode ) ||
-             ( Dali::DevelKey::DALI_KEY_DELETE == keyCode ) )
+    else if((Dali::DALI_KEY_BACKSPACE == keyCode) ||
+            (Dali::DevelKey::DALI_KEY_DELETE == keyCode))
     {
-      textChanged = controller.DeleteEvent( keyCode );
+      textChanged = controller.DeleteEvent(keyCode);
 
       // Will request for relayout.
       relayoutNeeded = true;
     }
-    else if( IsKey( keyEvent, Dali::DALI_KEY_POWER ) ||
-             IsKey( keyEvent, Dali::DALI_KEY_MENU ) ||
-             IsKey( keyEvent, Dali::DALI_KEY_HOME ) )
+    else if(IsKey(keyEvent, Dali::DALI_KEY_POWER) ||
+            IsKey(keyEvent, Dali::DALI_KEY_MENU) ||
+            IsKey(keyEvent, Dali::DALI_KEY_HOME))
     {
       // Power key/Menu/Home key behaviour does not allow edit mode to resume.
-      controller.mImpl->ChangeState( EventData::INACTIVE );
+      controller.mImpl->ChangeState(EventData::INACTIVE);
 
       // Will request for relayout.
       relayoutNeeded = true;
 
       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
     }
-    else if( ( Dali::DALI_KEY_SHIFT_LEFT == keyCode ) || ( Dali::DALI_KEY_SHIFT_RIGHT == keyCode ) )
+    else if((Dali::DALI_KEY_SHIFT_LEFT == keyCode) || (Dali::DALI_KEY_SHIFT_RIGHT == keyCode))
     {
       // DALI_KEY_SHIFT_LEFT or DALI_KEY_SHIFT_RIGHT is the key code for Shift. It's sent (by the InputMethodContext?) when the predictive text is enabled
       // and a character is typed after the type of a upper case latin character.
@@ -239,7 +235,7 @@ bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyE
       // Do nothing.
       return false;
     }
-    else if( ( Dali::DALI_KEY_VOLUME_UP == keyCode ) || ( Dali::DALI_KEY_VOLUME_DOWN == keyCode ) )
+    else if((Dali::DALI_KEY_VOLUME_UP == keyCode) || (Dali::DALI_KEY_VOLUME_DOWN == keyCode))
     {
       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
       // Do nothing.
@@ -247,52 +243,51 @@ bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyE
     }
     else
     {
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", &controller, keyString.c_str() );
-      if (!controller.IsEditable()) return false;
+      DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", &controller, keyString.c_str());
+      if(!controller.IsEditable()) return false;
 
-      if( !keyString.empty() )
+      if(!keyString.empty())
       {
         // InputMethodContext is no longer handling key-events
         controller.mImpl->ClearPreEditFlag();
 
-        controller.InsertText( keyString, COMMIT );
+        controller.InsertText(keyString, COMMIT);
 
         textChanged = true;
 
         // Will request for relayout.
         relayoutNeeded = true;
       }
-
     }
 
-    if ( ( controller.mImpl->mEventData->mState != EventData::INTERRUPTED ) &&
-         ( controller.mImpl->mEventData->mState != EventData::INACTIVE ) &&
-         ( !isNullKey ) &&
-         ( Dali::DALI_KEY_SHIFT_LEFT != keyCode ) &&
-         ( Dali::DALI_KEY_SHIFT_RIGHT != keyCode ) &&
-         ( Dali::DALI_KEY_VOLUME_UP != keyCode ) &&
-         ( Dali::DALI_KEY_VOLUME_DOWN != keyCode ) )
+    if((controller.mImpl->mEventData->mState != EventData::INTERRUPTED) &&
+       (controller.mImpl->mEventData->mState != EventData::INACTIVE) &&
+       (!isNullKey) &&
+       (Dali::DALI_KEY_SHIFT_LEFT != keyCode) &&
+       (Dali::DALI_KEY_SHIFT_RIGHT != keyCode) &&
+       (Dali::DALI_KEY_VOLUME_UP != keyCode) &&
+       (Dali::DALI_KEY_VOLUME_DOWN != keyCode))
     {
       // Should not change the state if the key is the shift send by the InputMethodContext.
       // Otherwise, when the state is SELECTING the text controller can't send the right
       // surrounding info to the InputMethodContext.
-      controller.mImpl->ChangeState( EventData::EDITING );
+      controller.mImpl->ChangeState(EventData::EDITING);
 
       // Will request for relayout.
       relayoutNeeded = true;
     }
 
-    if( relayoutNeeded )
+    if(relayoutNeeded)
     {
       controller.mImpl->RequestRelayout();
     }
   }
 
-  if( textChanged &&
-      ( NULL != controller.mImpl->mEditableControlInterface ) )
+  if(textChanged &&
+     (NULL != controller.mImpl->mEditableControlInterface))
   {
     // Do this last since it provides callbacks into application code
-    controller.mImpl->mEditableControlInterface->TextChanged();
+    controller.mImpl->mEditableControlInterface->TextChanged(false);
   }
 
   return true;
@@ -300,72 +295,72 @@ bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyE
 
 void Controller::EventHandler::TapEvent(Controller& controller, unsigned int tapCount, float x, float y)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected TapEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected TapEvent");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Concise, "TapEvent state:%d \n", controller.mImpl->mEventData->mState );
-    EventData::State state( controller.mImpl->mEventData->mState );
-    bool relayoutNeeded( false );   // to avoid unnecessary relayouts when tapping an empty text-field
+    DALI_LOG_INFO(gLogFilter, Debug::Concise, "TapEvent state:%d \n", controller.mImpl->mEventData->mState);
+    EventData::State state(controller.mImpl->mEventData->mState);
+    bool             relayoutNeeded(false); // to avoid unnecessary relayouts when tapping an empty text-field
 
-    if( controller.mImpl->IsClipboardVisible() )
+    if(controller.mImpl->IsClipboardVisible())
     {
-      if( EventData::INACTIVE == state || EventData::EDITING == state)
+      if(EventData::INACTIVE == state || EventData::EDITING == state)
       {
-        controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
+        controller.mImpl->ChangeState(EventData::EDITING_WITH_GRAB_HANDLE);
       }
       relayoutNeeded = true;
     }
-    else if( 1u == tapCount )
+    else if(1u == tapCount)
     {
-      if( EventData::EDITING_WITH_POPUP == state || EventData::EDITING_WITH_PASTE_POPUP == state )
+      if(EventData::EDITING_WITH_POPUP == state || EventData::EDITING_WITH_PASTE_POPUP == state)
       {
-        controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );  // If Popup shown hide it here so can be shown again if required.
+        controller.mImpl->ChangeState(EventData::EDITING_WITH_GRAB_HANDLE); // If Popup shown hide it here so can be shown again if required.
       }
 
-      if( controller.mImpl->IsShowingRealText() && ( EventData::INACTIVE != state ) )
+      if(controller.mImpl->IsShowingRealText() && (EventData::INACTIVE != state))
       {
-        controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
+        controller.mImpl->ChangeState(EventData::EDITING_WITH_GRAB_HANDLE);
         relayoutNeeded = true;
       }
       else
       {
-        if( controller.mImpl->IsShowingPlaceholderText() && !controller.mImpl->IsFocusedPlaceholderAvailable() )
+        if(controller.mImpl->IsShowingPlaceholderText() && !controller.mImpl->IsFocusedPlaceholderAvailable())
         {
           // Hide placeholder text
           controller.ResetText();
         }
 
-        if( EventData::INACTIVE == state )
+        if(EventData::INACTIVE == state)
         {
-          controller.mImpl->ChangeState( EventData::EDITING );
+          controller.mImpl->ChangeState(EventData::EDITING);
         }
-        else if( !controller.mImpl->IsClipboardEmpty() )
+        else if(!controller.mImpl->IsClipboardEmpty())
         {
-          controller.mImpl->ChangeState( EventData::EDITING_WITH_POPUP );
+          controller.mImpl->ChangeState(EventData::EDITING_WITH_POPUP);
         }
         relayoutNeeded = true;
       }
     }
-    else if( 2u == tapCount )
+    else if(2u == tapCount)
     {
-      if( controller.mImpl->mEventData->mSelectionEnabled &&
-          controller.mImpl->IsShowingRealText() )
+      if(controller.mImpl->mEventData->mSelectionEnabled &&
+         controller.mImpl->IsShowingRealText())
       {
-        relayoutNeeded = true;
-        controller.mImpl->mEventData->mIsLeftHandleSelected = true;
+        relayoutNeeded                                       = true;
+        controller.mImpl->mEventData->mIsLeftHandleSelected  = true;
         controller.mImpl->mEventData->mIsRightHandleSelected = true;
       }
     }
 
     // Handles & cursors must be repositioned after Relayout() i.e. after the Model has been updated
-    if( relayoutNeeded )
+    if(relayoutNeeded)
     {
-      Event event( Event::TAP_EVENT );
-      event.p1.mUint = tapCount;
+      Event event(Event::TAP_EVENT);
+      event.p1.mUint  = tapCount;
       event.p2.mFloat = x;
       event.p3.mFloat = y;
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
 
       controller.mImpl->RequestRelayout();
     }
@@ -377,15 +372,15 @@ void Controller::EventHandler::TapEvent(Controller& controller, unsigned int tap
 
 void Controller::EventHandler::PanEvent(Controller& controller, GestureState state, const Vector2& displacement)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected PanEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected PanEvent");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    Event event( Event::PAN_EVENT );
-    event.p1.mInt = static_cast<int>( state );
+    Event event(Event::PAN_EVENT);
+    event.p1.mInt   = static_cast<int>(state);
     event.p2.mFloat = displacement.x;
     event.p3.mFloat = displacement.y;
-    controller.mImpl->mEventData->mEventQueue.push_back( event );
+    controller.mImpl->mEventData->mEventQueue.push_back(event);
 
     controller.mImpl->RequestRelayout();
   }
@@ -393,46 +388,46 @@ void Controller::EventHandler::PanEvent(Controller& controller, GestureState sta
 
 void Controller::EventHandler::LongPressEvent(Controller& controller, GestureState state, float x, float y)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected LongPressEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected LongPressEvent");
 
-  if( ( state == GestureState::STARTED ) &&
-      ( NULL != controller.mImpl->mEventData ) )
+  if((state == GestureState::STARTED) &&
+     (NULL != controller.mImpl->mEventData))
   {
     // The 1st long-press on inactive text-field is treated as tap
-    if( EventData::INACTIVE == controller.mImpl->mEventData->mState )
+    if(EventData::INACTIVE == controller.mImpl->mEventData->mState)
     {
-      controller.mImpl->ChangeState( EventData::EDITING );
+      controller.mImpl->ChangeState(EventData::EDITING);
 
-      Event event( Event::TAP_EVENT );
-      event.p1.mUint = 1;
+      Event event(Event::TAP_EVENT);
+      event.p1.mUint  = 1;
       event.p2.mFloat = x;
       event.p3.mFloat = y;
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
 
       controller.mImpl->RequestRelayout();
     }
-    else if( !controller.mImpl->IsShowingRealText() )
+    else if(!controller.mImpl->IsShowingRealText())
     {
-      Event event( Event::LONG_PRESS_EVENT );
-      event.p1.mInt = static_cast<int>( state );
+      Event event(Event::LONG_PRESS_EVENT);
+      event.p1.mInt   = static_cast<int>(state);
       event.p2.mFloat = x;
       event.p3.mFloat = y;
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
       controller.mImpl->RequestRelayout();
     }
-    else if( !controller.mImpl->IsClipboardVisible() )
+    else if(!controller.mImpl->IsClipboardVisible())
     {
       // Reset the InputMethodContext to commit the pre-edit before selecting the text.
       controller.mImpl->ResetInputMethodContext();
 
-      Event event( Event::LONG_PRESS_EVENT );
-      event.p1.mInt = static_cast<int>( state );
+      Event event(Event::LONG_PRESS_EVENT);
+      event.p1.mInt   = static_cast<int>(state);
       event.p2.mFloat = x;
       event.p3.mFloat = y;
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
       controller.mImpl->RequestRelayout();
 
-      controller.mImpl->mEventData->mIsLeftHandleSelected = true;
+      controller.mImpl->mEventData->mIsLeftHandleSelected  = true;
       controller.mImpl->mEventData->mIsRightHandleSelected = true;
     }
   }
@@ -440,30 +435,30 @@ void Controller::EventHandler::LongPressEvent(Controller& controller, GestureSta
 
 void Controller::EventHandler::SelectEvent(Controller& controller, float x, float y, SelectionType selectType)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SelectEvent\n" );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::SelectEvent\n");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    if( selectType == SelectionType::ALL )
+    if(selectType == SelectionType::ALL)
     {
-      Event event( Event::SELECT_ALL );
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      Event event(Event::SELECT_ALL);
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
     }
-    else if( selectType == SelectionType::NONE )
+    else if(selectType == SelectionType::NONE)
     {
-      Event event( Event::SELECT_NONE );
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      Event event(Event::SELECT_NONE);
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
     }
     else
     {
-      Event event( Event::SELECT );
+      Event event(Event::SELECT);
       event.p2.mFloat = x;
       event.p3.mFloat = y;
-      controller.mImpl->mEventData->mEventQueue.push_back( event );
+      controller.mImpl->mEventData->mEventQueue.push_back(event);
     }
 
-    controller.mImpl->mEventData->mCheckScrollAmount = true;
-    controller.mImpl->mEventData->mIsLeftHandleSelected = true;
+    controller.mImpl->mEventData->mCheckScrollAmount     = true;
+    controller.mImpl->mEventData->mIsLeftHandleSelected  = true;
     controller.mImpl->mEventData->mIsRightHandleSelected = true;
     controller.mImpl->RequestRelayout();
   }
@@ -473,47 +468,47 @@ void Controller::EventHandler::ProcessModifyEvents(Controller& controller)
 {
   Vector<ModifyEvent>& events = controller.mImpl->mModifyEvents;
 
-  if( 0u == events.Count() )
+  if(0u == events.Count())
   {
     // Nothing to do.
     return;
   }
 
-  for( Vector<ModifyEvent>::ConstIterator it = events.Begin(),
-         endIt = events.End();
-       it != endIt;
-       ++it )
+  for(Vector<ModifyEvent>::ConstIterator it    = events.Begin(),
+                                         endIt = events.End();
+      it != endIt;
+      ++it)
   {
     const ModifyEvent& event = *it;
 
-    if( ModifyEvent::TEXT_REPLACED == event.type )
+    if(ModifyEvent::TEXT_REPLACED == event.type)
     {
       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
-      DALI_ASSERT_DEBUG( it == events.Begin() && "Unexpected TEXT_REPLACED event" );
+      DALI_ASSERT_DEBUG(it == events.Begin() && "Unexpected TEXT_REPLACED event");
 
       controller.TextReplacedEvent();
     }
-    else if( ModifyEvent::TEXT_INSERTED == event.type )
+    else if(ModifyEvent::TEXT_INSERTED == event.type)
     {
       controller.TextInsertedEvent();
     }
-    else if( ModifyEvent::TEXT_DELETED == event.type )
+    else if(ModifyEvent::TEXT_DELETED == event.type)
     {
       // Placeholder-text cannot be deleted
-      if( !controller.mImpl->IsShowingPlaceholderText() )
+      if(!controller.mImpl->IsShowingPlaceholderText())
       {
         controller.TextDeletedEvent();
       }
     }
   }
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
     // When the text is being modified, delay cursor blinking
     controller.mImpl->mEventData->mDecorator->DelayCursorBlink();
 
     // Update selection position after modifying the text
-    controller.mImpl->mEventData->mLeftSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
+    controller.mImpl->mEventData->mLeftSelectionPosition  = controller.mImpl->mEventData->mPrimaryCursorPosition;
     controller.mImpl->mEventData->mRightSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
   }
 
@@ -535,9 +530,9 @@ void Controller::EventHandler::TextReplacedEvent(Controller& controller)
 
 void Controller::EventHandler::TextInsertedEvent(Controller& controller)
 {
-  DALI_ASSERT_DEBUG( NULL != controller.mImpl->mEventData && "Unexpected TextInsertedEvent" );
+  DALI_ASSERT_DEBUG(NULL != controller.mImpl->mEventData && "Unexpected TextInsertedEvent");
 
-  if( NULL == controller.mImpl->mEventData )
+  if(NULL == controller.mImpl->mEventData)
   {
     return;
   }
@@ -556,14 +551,14 @@ void Controller::EventHandler::TextInsertedEvent(Controller& controller)
 
 void Controller::EventHandler::TextDeletedEvent(Controller& controller)
 {
-  DALI_ASSERT_DEBUG( NULL != controller.mImpl->mEventData && "Unexpected TextDeletedEvent" );
+  DALI_ASSERT_DEBUG(NULL != controller.mImpl->mEventData && "Unexpected TextDeletedEvent");
 
-  if( NULL == controller.mImpl->mEventData )
+  if(NULL == controller.mImpl->mEventData)
   {
     return;
   }
 
-  if (!controller.IsEditable()) return;
+  if(!controller.IsEditable()) return;
 
   controller.mImpl->mEventData->mCheckScrollAmount = true;
 
@@ -579,52 +574,52 @@ void Controller::EventHandler::TextDeletedEvent(Controller& controller)
 
 bool Controller::EventHandler::DeleteEvent(Controller& controller, int keyCode)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p KeyCode : %d \n", &controller, keyCode );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::KeyEvent %p KeyCode : %d \n", &controller, keyCode);
 
   bool removed = false;
 
-  if( NULL == controller.mImpl->mEventData )
+  if(NULL == controller.mImpl->mEventData)
   {
     return removed;
   }
 
-  if (!controller.IsEditable()) return false;
+  if(!controller.IsEditable()) return false;
 
   // InputMethodContext is no longer handling key-events
   controller.mImpl->ClearPreEditFlag();
 
-  if( EventData::SELECTING == controller.mImpl->mEventData->mState )
+  if(EventData::SELECTING == controller.mImpl->mEventData->mState)
   {
     removed = controller.RemoveSelectedText();
   }
-  else if( ( controller.mImpl->mEventData->mPrimaryCursorPosition > 0 ) && ( keyCode == Dali::DALI_KEY_BACKSPACE) )
+  else if((controller.mImpl->mEventData->mPrimaryCursorPosition > 0) && (keyCode == Dali::DALI_KEY_BACKSPACE))
   {
     // Remove the character before the current cursor position
-    removed = controller.RemoveText( -1,
-                          1,
-                          UPDATE_INPUT_STYLE );
+    removed = controller.RemoveText(-1,
+                                    1,
+                                    UPDATE_INPUT_STYLE);
   }
-  else if( keyCode == Dali::DevelKey::DALI_KEY_DELETE )
+  else if(keyCode == Dali::DevelKey::DALI_KEY_DELETE)
   {
     // Remove the character after the current cursor position
-    removed = controller.RemoveText( 0,
-                          1,
-                          UPDATE_INPUT_STYLE );
+    removed = controller.RemoveText(0,
+                                    1,
+                                    UPDATE_INPUT_STYLE);
   }
 
-  if( removed )
+  if(removed)
   {
-    if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
-        !controller.mImpl->IsPlaceholderAvailable() )
+    if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
+       !controller.mImpl->IsPlaceholderAvailable())
     {
-      controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+      controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
     }
     else
     {
       controller.ShowPlaceholderText();
     }
     controller.mImpl->mEventData->mUpdateCursorPosition = true;
-    controller.mImpl->mEventData->mScrollAfterDelete = true;
+    controller.mImpl->mEventData->mScrollAfterDelete    = true;
   }
 
   return removed;
@@ -636,44 +631,44 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
   bool requestRelayout = false;
 
   // Whether to retrieve the text and cursor position to be sent to the InputMethodContext.
-  bool retrieveText = false;
+  bool retrieveText   = false;
   bool retrieveCursor = false;
 
-  switch( inputMethodContextEvent.eventName )
+  switch(inputMethodContextEvent.eventName)
   {
     case InputMethodContext::COMMIT:
     {
-      controller.InsertText( inputMethodContextEvent.predictiveString, Text::Controller::COMMIT );
+      controller.InsertText(inputMethodContextEvent.predictiveString, Text::Controller::COMMIT);
       requestRelayout = true;
-      retrieveCursor = true;
+      retrieveCursor  = true;
       break;
     }
     case InputMethodContext::PRE_EDIT:
     {
-      controller.InsertText( inputMethodContextEvent.predictiveString, Text::Controller::PRE_EDIT );
+      controller.InsertText(inputMethodContextEvent.predictiveString, Text::Controller::PRE_EDIT);
       requestRelayout = true;
-      retrieveCursor = true;
+      retrieveCursor  = true;
       break;
     }
     case InputMethodContext::DELETE_SURROUNDING:
     {
-      const bool textDeleted = controller.RemoveText( inputMethodContextEvent.cursorOffset,
-                                                      inputMethodContextEvent.numberOfChars,
-                                                      DONT_UPDATE_INPUT_STYLE );
+      const bool textDeleted = controller.RemoveText(inputMethodContextEvent.cursorOffset,
+                                                     inputMethodContextEvent.numberOfChars,
+                                                     DONT_UPDATE_INPUT_STYLE);
 
-      if( textDeleted )
+      if(textDeleted)
       {
-        if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
-            !controller.mImpl->IsPlaceholderAvailable() )
+        if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
+           !controller.mImpl->IsPlaceholderAvailable())
         {
-          controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+          controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
         }
         else
         {
           controller.ShowPlaceholderText();
         }
         controller.mImpl->mEventData->mUpdateCursorPosition = true;
-        controller.mImpl->mEventData->mScrollAfterDelete = true;
+        controller.mImpl->mEventData->mScrollAfterDelete    = true;
 
         requestRelayout = true;
       }
@@ -681,14 +676,14 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
     }
     case InputMethodContext::GET_SURROUNDING:
     {
-      retrieveText = true;
+      retrieveText   = true;
       retrieveCursor = true;
       break;
     }
     case InputMethodContext::PRIVATE_COMMAND:
     {
       // PRIVATECOMMAND event is just for getting the private command message
-      retrieveText = true;
+      retrieveText   = true;
       retrieveCursor = true;
       break;
     }
@@ -699,23 +694,23 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
     }
   } // end switch
 
-  if( requestRelayout )
+  if(requestRelayout)
   {
     controller.mImpl->mOperationsPending = ALL_OPERATIONS;
     controller.mImpl->RequestRelayout();
   }
 
-  std::string text;
-  CharacterIndex cursorPosition = 0u;
-  Length numberOfWhiteSpaces = 0u;
+  std::string    text;
+  CharacterIndex cursorPosition      = 0u;
+  Length         numberOfWhiteSpaces = 0u;
 
-  if( retrieveCursor )
+  if(retrieveCursor)
   {
-    numberOfWhiteSpaces = controller.mImpl->GetNumberOfWhiteSpaces( 0u );
+    numberOfWhiteSpaces = controller.mImpl->GetNumberOfWhiteSpaces(0u);
 
     cursorPosition = controller.mImpl->GetLogicalCursorPosition();
 
-    if( cursorPosition < numberOfWhiteSpaces )
+    if(cursorPosition < numberOfWhiteSpaces)
     {
       cursorPosition = 0u;
     }
@@ -725,12 +720,12 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
     }
   }
 
-  if( retrieveText )
+  if(retrieveText)
   {
-    if( !controller.mImpl->IsShowingPlaceholderText() )
+    if(!controller.mImpl->IsShowingPlaceholderText())
     {
       // Retrieves the normal text string.
-      controller.mImpl->GetText( numberOfWhiteSpaces, text );
+      controller.mImpl->GetText(numberOfWhiteSpaces, text);
     }
     else
     {
@@ -740,13 +735,13 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
     }
   }
 
-  InputMethodContext::CallbackData callbackData( ( retrieveText || retrieveCursor ), cursorPosition, text, false );
+  InputMethodContext::CallbackData callbackData((retrieveText || retrieveCursor), cursorPosition, text, false);
 
-  if( requestRelayout &&
-      ( NULL != controller.mImpl->mEditableControlInterface ) )
+  if(requestRelayout &&
+     (NULL != controller.mImpl->mEditableControlInterface))
   {
     // Do this last since it provides callbacks into application code
-    controller.mImpl->mEditableControlInterface->TextChanged();
+    controller.mImpl->mEditableControlInterface->TextChanged(false);
   }
 
   return callbackData;
@@ -755,57 +750,57 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
 void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller)
 {
   // Retrieve the clipboard contents first
-  ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
-  std::string stringToPaste( notifier.GetContent() );
+  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  std::string            stringToPaste(notifier.GetContent());
 
   // Commit the current pre-edit text; the contents of the clipboard should be appended
   controller.mImpl->ResetInputMethodContext();
 
   // Temporary disable hiding clipboard
-  controller.mImpl->SetClipboardHideEnable( false );
+  controller.mImpl->SetClipboardHideEnable(false);
 
   // Paste
-  controller.PasteText( stringToPaste );
+  controller.PasteText(stringToPaste);
 
-  controller.mImpl->SetClipboardHideEnable( true );
+  controller.mImpl->SetClipboardHideEnable(true);
 }
 
 void Controller::EventHandler::DecorationEvent(Controller& controller, HandleType handleType, HandleState state, float x, float y)
 {
-  DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected DecorationEvent" );
+  DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected DecorationEvent");
 
-  if( NULL != controller.mImpl->mEventData )
+  if(NULL != controller.mImpl->mEventData)
   {
-    switch( handleType )
+    switch(handleType)
     {
       case GRAB_HANDLE:
       {
-        Event event( Event::GRAB_HANDLE_EVENT );
+        Event event(Event::GRAB_HANDLE_EVENT);
         event.p1.mUint  = state;
         event.p2.mFloat = x;
         event.p3.mFloat = y;
 
-        controller.mImpl->mEventData->mEventQueue.push_back( event );
+        controller.mImpl->mEventData->mEventQueue.push_back(event);
         break;
       }
       case LEFT_SELECTION_HANDLE:
       {
-        Event event( Event::LEFT_SELECTION_HANDLE_EVENT );
+        Event event(Event::LEFT_SELECTION_HANDLE_EVENT);
         event.p1.mUint  = state;
         event.p2.mFloat = x;
         event.p3.mFloat = y;
 
-        controller.mImpl->mEventData->mEventQueue.push_back( event );
+        controller.mImpl->mEventData->mEventQueue.push_back(event);
         break;
       }
       case RIGHT_SELECTION_HANDLE:
       {
-        Event event( Event::RIGHT_SELECTION_HANDLE_EVENT );
+        Event event(Event::RIGHT_SELECTION_HANDLE_EVENT);
         event.p1.mUint  = state;
         event.p2.mFloat = x;
         event.p3.mFloat = y;
 
-        controller.mImpl->mEventData->mEventQueue.push_back( event );
+        controller.mImpl->mEventData->mEventQueue.push_back(event);
         break;
       }
       case LEFT_SELECTION_HANDLE_MARKER:
@@ -816,7 +811,7 @@ void Controller::EventHandler::DecorationEvent(Controller& controller, HandleTyp
       }
       case HANDLE_TYPE_COUNT:
       {
-        DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
+        DALI_ASSERT_DEBUG(!"Controller::HandleEvent. Unexpected handle type");
       }
     }
 
@@ -826,23 +821,23 @@ void Controller::EventHandler::DecorationEvent(Controller& controller, HandleTyp
 
 void Controller::EventHandler::TextPopupButtonTouched(Controller& controller, Dali::Toolkit::TextSelectionPopup::Buttons button)
 {
-  if( NULL == controller.mImpl->mEventData )
+  if(NULL == controller.mImpl->mEventData)
   {
     return;
   }
 
-  switch( button )
+  switch(button)
   {
     case Toolkit::TextSelectionPopup::CUT:
     {
-      if (!controller.IsEditable()) return;
-      controller.mImpl->SendSelectionToClipboard( true ); // Synchronous call to modify text
+      if(!controller.IsEditable()) return;
+      controller.mImpl->SendSelectionToClipboard(true); // Synchronous call to modify text
       controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 
-      if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
-          !controller.mImpl->IsPlaceholderAvailable() )
+      if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
+         !controller.mImpl->IsPlaceholderAvailable())
       {
-        controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
+        controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
       }
       else
       {
@@ -850,19 +845,19 @@ void Controller::EventHandler::TextPopupButtonTouched(Controller& controller, Da
       }
 
       controller.mImpl->mEventData->mUpdateCursorPosition = true;
-      controller.mImpl->mEventData->mScrollAfterDelete = true;
+      controller.mImpl->mEventData->mScrollAfterDelete    = true;
 
       controller.mImpl->RequestRelayout();
 
-      if( NULL != controller.mImpl->mEditableControlInterface )
+      if(NULL != controller.mImpl->mEditableControlInterface)
       {
-        controller.mImpl->mEditableControlInterface->TextChanged();
+        controller.mImpl->mEditableControlInterface->TextChanged(true);
       }
       break;
     }
     case Toolkit::TextSelectionPopup::COPY:
     {
-      controller.mImpl->SendSelectionToClipboard( false ); // Text not modified
+      controller.mImpl->SendSelectionToClipboard(false); // Text not modified
 
       controller.mImpl->mEventData->mUpdateCursorPosition = true;
 
@@ -876,19 +871,19 @@ void Controller::EventHandler::TextPopupButtonTouched(Controller& controller, Da
     }
     case Toolkit::TextSelectionPopup::SELECT:
     {
-      const Vector2& currentCursorPosition = controller.mImpl->mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
+      const Vector2& currentCursorPosition = controller.mImpl->mEventData->mDecorator->GetPosition(PRIMARY_CURSOR);
 
-      if( controller.mImpl->mEventData->mSelectionEnabled )
+      if(controller.mImpl->mEventData->mSelectionEnabled)
       {
         // Creates a SELECT event.
-        controller.SelectEvent( currentCursorPosition.x, currentCursorPosition.y, SelectionType::INTERACTIVE );
+        controller.SelectEvent(currentCursorPosition.x, currentCursorPosition.y, SelectionType::INTERACTIVE);
       }
       break;
     }
     case Toolkit::TextSelectionPopup::SELECT_ALL:
     {
       // Creates a SELECT_ALL event
-      controller.SelectEvent( 0.f, 0.f, SelectionType::ALL );
+      controller.SelectEvent(0.f, 0.f, SelectionType::ALL);
       break;
     }
     case Toolkit::TextSelectionPopup::CLIPBOARD:

diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 6e9148b..f81f01d
--- a/dali-toolkit/internal/text/text-controller.cpp
+++ b/dali-toolkit/internal/text/text-controller.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,10 +19,10 @@
 #include <dali-toolkit/internal/text/text-controller.h>
 
 // EXTERNAL INCLUDES
-#include <limits>
-#include <cmath>
-#include <memory.h>
 #include <dali/integration-api/debug.h>
+#include <memory.h>
+#include <cmath>
+#include <limits>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/internal/text/character-set-conversion.h>
@@ -36,7 +36,6 @@
 
 namespace
 {
-
 #if defined(DEBUG_ENABLED)
 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
 #endif
@@ -45,59 +44,56 @@ const float MAX_FLOAT = std::numeric_limits<float>::max();
 
 const std::string EMPTY_STRING("");
 
-float ConvertToEven( float value )
+float ConvertToEven(float value)
 {
-  int intValue(static_cast<int>( value ));
-  return static_cast<float>( intValue + ( intValue & 1 ) );
+  int intValue(static_cast<int>(value));
+  return static_cast<float>(intValue + (intValue & 1));
 }
 
-int ConvertPixelToPint( float pixel )
+int ConvertPixelToPint(float pixel)
 {
-  unsigned int horizontalDpi = 0u;
-  unsigned int verticalDpi = 0u;
-  Dali::TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
-  fontClient.GetDpi( horizontalDpi, verticalDpi );
+  unsigned int                      horizontalDpi = 0u;
+  unsigned int                      verticalDpi   = 0u;
+  Dali::TextAbstraction::FontClient fontClient    = Dali::TextAbstraction::FontClient::Get();
+  fontClient.GetDpi(horizontalDpi, verticalDpi);
 
-  return ( pixel * 72.f ) / static_cast< float >( horizontalDpi );
+  return (pixel * 72.f) / static_cast<float>(horizontalDpi);
 }
 
 } // namespace
 
 namespace Dali
 {
-
 namespace Toolkit
 {
-
 namespace Text
 {
-
 // public : Constructor.
 
 ControllerPtr Controller::New()
 {
-  return ControllerPtr( new Controller() );
+  return ControllerPtr(new Controller());
 }
 
-ControllerPtr Controller::New( ControlInterface* controlInterface )
+ControllerPtr Controller::New(ControlInterface* controlInterface)
 {
-  return ControllerPtr( new Controller( controlInterface ) );
+  return ControllerPtr(new Controller(controlInterface));
 }
 
-ControllerPtr Controller::New( ControlInterface* controlInterface,
-                               EditableControlInterface* editableControlInterface,
-                               SelectableControlInterface* selectableControlInterface )
+ControllerPtr Controller::New(ControlInterface*           controlInterface,
+                              EditableControlInterface*   editableControlInterface,
+                              SelectableControlInterface* selectableControlInterface)
 {
-  return ControllerPtr( new Controller( controlInterface,
-                                        editableControlInterface,
-                                        selectableControlInterface ) );
+  return ControllerPtr(new Controller(controlInterface,
+                                      editableControlInterface,
+                                      selectableControlInterface));
 }
 
 // public : Configure the text controller.
 
-void Controller::EnableTextInput( DecoratorPtr decorator, InputMethodContext& inputMethodContext )
+void Controller::EnableTextInput(DecoratorPtr decorator, InputMethodContext& inputMethodContext)
 {
-  if( !decorator )
+  if(!decorator)
   {
     delete mImpl->mEventData;
     mImpl->mEventData = NULL;
@@ -106,16 +102,16 @@ void Controller::EnableTextInput( DecoratorPtr decorator, InputMethodContext& in
     return;
   }
 
-  if( NULL == mImpl->mEventData )
+  if(NULL == mImpl->mEventData)
   {
-    mImpl->mEventData = new EventData( decorator, inputMethodContext );
+    mImpl->mEventData = new EventData(decorator, inputMethodContext);
   }
 }
 
-void Controller::SetGlyphType( TextAbstraction::GlyphType glyphType )
+void Controller::SetGlyphType(TextAbstraction::GlyphType glyphType)
 {
   // Metrics for bitmap & vector based glyphs are different
-  mImpl->mMetrics->SetGlyphType( glyphType );
+  mImpl->mMetrics->SetGlyphType(glyphType);
 
   // Clear the font-specific data
   ClearFontData();
@@ -123,15 +119,15 @@ void Controller::SetGlyphType( TextAbstraction::GlyphType glyphType )
   mImpl->RequestRelayout();
 }
 
-void Controller::SetMarkupProcessorEnabled( bool enable )
+void Controller::SetMarkupProcessorEnabled(bool enable)
 {
-  if( enable != mImpl->mMarkupProcessorEnabled )
+  if(enable != mImpl->mMarkupProcessorEnabled)
   {
     //If Text was already set, call the SetText again for enabling or disabling markup
     mImpl->mMarkupProcessorEnabled = enable;
     std::string text;
-    GetText( text );
-    SetText( text );
+    GetText(text);
+    SetText(text);
   }
 }
 
@@ -140,31 +136,30 @@ bool Controller::IsMarkupProcessorEnabled() const
   return mImpl->mMarkupProcessorEnabled;
 }
 
-void Controller::SetAutoScrollEnabled( bool enable )
+void Controller::SetAutoScrollEnabled(bool enable)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled[%s] SingleBox[%s]-> [%p]\n", (enable)?"true":"false", ( mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX)?"true":"false", this );
+  DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled[%s] SingleBox[%s]-> [%p]\n", (enable) ? "true" : "false", (mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX) ? "true" : "false", this);
 
-  if( mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX )
+  if(mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX)
   {
-    if( enable )
+    if(enable)
     {
-      DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled for SINGLE_LINE_BOX\n" );
-      mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                               LAYOUT                    |
-                                                               ALIGN                     |
-                                                               UPDATE_LAYOUT_SIZE        |
-                                                               UPDATE_DIRECTION          |
-                                                               REORDER );
-
+      DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled for SINGLE_LINE_BOX\n");
+      mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                              LAYOUT |
+                                                              ALIGN |
+                                                              UPDATE_LAYOUT_SIZE |
+                                                              UPDATE_DIRECTION |
+                                                              REORDER);
     }
     else
     {
-      DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled Disabling autoscroll\n");
-      mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                               LAYOUT                    |
-                                                               ALIGN                     |
-                                                               UPDATE_LAYOUT_SIZE        |
-                                                               REORDER );
+      DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled Disabling autoscroll\n");
+      mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                              LAYOUT |
+                                                              ALIGN |
+                                                              UPDATE_LAYOUT_SIZE |
+                                                              REORDER);
     }
 
     mImpl->mIsAutoScrollEnabled = enable;
@@ -172,14 +167,14 @@ void Controller::SetAutoScrollEnabled( bool enable )
   }
   else
   {
-    DALI_LOG_WARNING( "Attempted AutoScrolling on a non SINGLE_LINE_BOX, request ignored\n" );
+    DALI_LOG_WARNING("Attempted AutoScrolling on a non SINGLE_LINE_BOX, request ignored\n");
     mImpl->mIsAutoScrollEnabled = false;
   }
 }
 
 bool Controller::IsAutoScrollEnabled() const
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::IsAutoScrollEnabled[%s]\n", mImpl->mIsAutoScrollEnabled?"true":"false" );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::IsAutoScrollEnabled[%s]\n", mImpl->mIsAutoScrollEnabled ? "true" : "false");
 
   return mImpl->mIsAutoScrollEnabled;
 }
@@ -193,27 +188,27 @@ float Controller::GetAutoScrollLineAlignment() const
 {
   float offset = 0.f;
 
-  if( mImpl->mModel->mVisualModel &&
-      ( 0u != mImpl->mModel->mVisualModel->mLines.Count() ) )
+  if(mImpl->mModel->mVisualModel &&
+     (0u != mImpl->mModel->mVisualModel->mLines.Count()))
   {
-    offset = ( *mImpl->mModel->mVisualModel->mLines.Begin() ).alignmentOffset;
+    offset = (*mImpl->mModel->mVisualModel->mLines.Begin()).alignmentOffset;
   }
 
   return offset;
 }
 
-void Controller::SetHorizontalScrollEnabled( bool enable )
+void Controller::SetHorizontalScrollEnabled(bool enable)
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
-    mImpl->mEventData->mDecorator->SetHorizontalScrollEnabled( enable );
+    mImpl->mEventData->mDecorator->SetHorizontalScrollEnabled(enable);
   }
 }
 bool Controller::IsHorizontalScrollEnabled() const
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
     return mImpl->mEventData->mDecorator->IsHorizontalScrollEnabled();
   }
@@ -221,22 +216,22 @@ bool Controller::IsHorizontalScrollEnabled() const
   return false;
 }
 
-void Controller::SetVerticalScrollEnabled( bool enable )
+void Controller::SetVerticalScrollEnabled(bool enable)
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
-    if( mImpl->mEventData->mDecorator )
+    if(mImpl->mEventData->mDecorator)
     {
-      mImpl->mEventData->mDecorator->SetVerticalScrollEnabled( enable );
+      mImpl->mEventData->mDecorator->SetVerticalScrollEnabled(enable);
     }
   }
 }
 
 bool Controller::IsVerticalScrollEnabled() const
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
     return mImpl->mEventData->mDecorator->IsVerticalScrollEnabled();
   }
@@ -244,19 +239,19 @@ bool Controller::IsVerticalScrollEnabled() const
   return false;
 }
 
-void Controller::SetSmoothHandlePanEnabled( bool enable )
+void Controller::SetSmoothHandlePanEnabled(bool enable)
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
-    mImpl->mEventData->mDecorator->SetSmoothHandlePanEnabled( enable );
+    mImpl->mEventData->mDecorator->SetSmoothHandlePanEnabled(enable);
   }
 }
 
 bool Controller::IsSmoothHandlePanEnabled() const
 {
-  if( ( NULL != mImpl->mEventData ) &&
-      mImpl->mEventData->mDecorator )
+  if((NULL != mImpl->mEventData) &&
+     mImpl->mEventData->mDecorator)
   {
     return mImpl->mEventData->mDecorator->IsSmoothHandlePanEnabled();
   }
@@ -264,7 +259,7 @@ bool Controller::IsSmoothHandlePanEnabled() const
   return false;
 }
 
-void Controller::SetMaximumNumberOfCharacters( Length maxCharacters )
+void Controller::SetMaximumNumberOfCharacters(Length maxCharacters)
 {
   mImpl->mMaximumNumberOfCharacters = maxCharacters;
 }
@@ -274,16 +269,16 @@ int Controller::GetMaximumNumberOfCharacters()
   return mImpl->mMaximumNumberOfCharacters;
 }
 
-void Controller::SetEnableCursorBlink( bool enable )
+void Controller::SetEnableCursorBlink(bool enable)
 {
-  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "TextInput disabled" );
+  DALI_ASSERT_DEBUG(NULL != mImpl->mEventData && "TextInput disabled");
 
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mCursorBlinkEnabled = enable;
 
-    if( !enable &&
-        mImpl->mEventData->mDecorator )
+    if(!enable &&
+       mImpl->mEventData->mDecorator)
     {
       mImpl->mEventData->mDecorator->StopCursorBlink();
     }
@@ -292,7 +287,7 @@ void Controller::SetEnableCursorBlink( bool enable )
 
 bool Controller::GetEnableCursorBlink() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mCursorBlinkEnabled;
   }
@@ -300,23 +295,23 @@ bool Controller::GetEnableCursorBlink() const
   return false;
 }
 
-void Controller::SetMultiLineEnabled( bool enable )
+void Controller::SetMultiLineEnabled(bool enable)
 {
   const Layout::Engine::Type layout = enable ? Layout::Engine::MULTI_LINE_BOX : Layout::Engine::SINGLE_LINE_BOX;
 
-  if( layout != mImpl->mLayoutEngine.GetLayout() )
+  if(layout != mImpl->mLayoutEngine.GetLayout())
   {
     // Set the layout type.
-    mImpl->mLayoutEngine.SetLayout( layout );
+    mImpl->mLayoutEngine.SetLayout(layout);
 
     // Set the flags to redo the layout operations
-    const OperationsMask layoutOperations =  static_cast<OperationsMask>( LAYOUT             |
-                                                                          UPDATE_LAYOUT_SIZE |
-                                                                          ALIGN              |
-                                                                          REORDER );
+    const OperationsMask layoutOperations = static_cast<OperationsMask>(LAYOUT |
+                                                                        UPDATE_LAYOUT_SIZE |
+                                                                        ALIGN |
+                                                                        REORDER);
 
     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | layoutOperations );
+    mImpl->mOperationsPending                  = static_cast<OperationsMask>(mImpl->mOperationsPending | layoutOperations);
 
     // Need to recalculate natural size
     mImpl->mRecalculateNaturalSize = true;
@@ -330,24 +325,24 @@ bool Controller::IsMultiLineEnabled() const
   return Layout::Engine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout();
 }
 
-void Controller::SetHorizontalAlignment( Text::HorizontalAlignment::Type alignment )
+void Controller::SetHorizontalAlignment(Text::HorizontalAlignment::Type alignment)
 {
-  if( alignment != mImpl->mModel->mHorizontalAlignment )
+  if(alignment != mImpl->mModel->mHorizontalAlignment)
   {
     // Set the alignment.
     mImpl->mModel->mHorizontalAlignment = alignment;
 
     // Set the flag to redo the alignment operation.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | ALIGN);
 
-    if( mImpl->mEventData )
+    if(mImpl->mEventData)
     {
       mImpl->mEventData->mUpdateAlignment = true;
 
       // Update the cursor if it's in editing mode
-      if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+      if(EventData::IsEditingState(mImpl->mEventData->mState))
       {
-        mImpl->ChangeState( EventData::EDITING );
+        mImpl->ChangeState(EventData::EDITING);
         mImpl->mEventData->mUpdateCursorPosition = true;
       }
     }
@@ -361,14 +356,14 @@ Text::HorizontalAlignment::Type Controller::GetHorizontalAlignment() const
   return mImpl->mModel->mHorizontalAlignment;
 }
 
-void Controller::SetVerticalAlignment( VerticalAlignment::Type alignment )
+void Controller::SetVerticalAlignment(VerticalAlignment::Type alignment)
 {
-  if( alignment != mImpl->mModel->mVerticalAlignment )
+  if(alignment != mImpl->mModel->mVerticalAlignment)
   {
     // Set the alignment.
     mImpl->mModel->mVerticalAlignment = alignment;
 
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | ALIGN);
 
     mImpl->RequestRelayout();
   }
@@ -384,7 +379,7 @@ bool Controller::IsIgnoreSpacesAfterText() const
   return mImpl->mModel->mIgnoreSpacesAfterText;
 }
 
-void Controller::SetIgnoreSpacesAfterText( bool ignore )
+void Controller::SetIgnoreSpacesAfterText(bool ignore)
 {
   mImpl->mModel->mIgnoreSpacesAfterText = ignore;
 }
@@ -394,12 +389,12 @@ bool Controller::IsMatchSystemLanguageDirection() const
   return mImpl->mModel->mMatchSystemLanguageDirection;
 }
 
-void Controller::SetMatchSystemLanguageDirection( bool match )
+void Controller::SetMatchSystemLanguageDirection(bool match)
 {
   mImpl->mModel->mMatchSystemLanguageDirection = match;
 }
 
-void Controller::SetLayoutDirection( Dali::LayoutDirection::Type layoutDirection )
+void Controller::SetLayoutDirection(Dali::LayoutDirection::Type layoutDirection)
 {
   mImpl->mLayoutDirection = layoutDirection;
 }
@@ -409,24 +404,22 @@ bool Controller::IsShowingRealText() const
   return mImpl->IsShowingRealText();
 }
 
-
-void Controller::SetLineWrapMode( Text::LineWrap::Mode lineWrapMode )
+void Controller::SetLineWrapMode(Text::LineWrap::Mode lineWrapMode)
 {
-  if( lineWrapMode != mImpl->mModel->mLineWrapMode )
+  if(lineWrapMode != mImpl->mModel->mLineWrapMode)
   {
     // Set the text wrap mode.
     mImpl->mModel->mLineWrapMode = lineWrapMode;
 
-
     // Update Text layout for applying wrap mode
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                             ALIGN                     |
-                                                             LAYOUT                    |
-                                                             UPDATE_LAYOUT_SIZE        |
-                                                             REORDER                   );
-    mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+    mImpl->mOperationsPending                          = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                            ALIGN |
+                                                            LAYOUT |
+                                                            UPDATE_LAYOUT_SIZE |
+                                                            REORDER);
+    mImpl->mTextUpdateInfo.mCharacterIndex             = 0u;
     mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-    mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
+    mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = mImpl->mModel->mLogicalModel->mText.Count();
 
     // Request relayout
     mImpl->RequestRelayout();
@@ -438,7 +431,7 @@ Text::LineWrap::Mode Controller::GetLineWrapMode() const
   return mImpl->mModel->mLineWrapMode;
 }
 
-void Controller::SetTextElideEnabled( bool enabled )
+void Controller::SetTextElideEnabled(bool enabled)
 {
   mImpl->mModel->mElideEnabled = enabled;
 }
@@ -458,9 +451,9 @@ bool Controller::IsTextFitEnabled() const
   return mImpl->mTextFitEnabled;
 }
 
-void Controller::SetTextFitMinSize( float minSize, FontSizeType type )
+void Controller::SetTextFitMinSize(float minSize, FontSizeType type)
 {
-  switch( type )
+  switch(type)
   {
     case POINT_SIZE:
     {
@@ -469,7 +462,7 @@ void Controller::SetTextFitMinSize( float minSize, FontSizeType type )
     }
     case PIXEL_SIZE:
     {
-      mImpl->mTextFitMinSize = ConvertPixelToPint( minSize );
+      mImpl->mTextFitMinSize = ConvertPixelToPint(minSize);
       break;
     }
   }
@@ -480,9 +473,9 @@ float Controller::GetTextFitMinSize() const
   return mImpl->mTextFitMinSize;
 }
 
-void Controller::SetTextFitMaxSize( float maxSize, FontSizeType type )
+void Controller::SetTextFitMaxSize(float maxSize, FontSizeType type)
 {
-  switch( type )
+  switch(type)
   {
     case POINT_SIZE:
     {
@@ -491,7 +484,7 @@ void Controller::SetTextFitMaxSize( float maxSize, FontSizeType type )
     }
     case PIXEL_SIZE:
     {
-      mImpl->mTextFitMaxSize = ConvertPixelToPint( maxSize );
+      mImpl->mTextFitMaxSize = ConvertPixelToPint(maxSize);
       break;
     }
   }
@@ -502,9 +495,9 @@ float Controller::GetTextFitMaxSize() const
   return mImpl->mTextFitMaxSize;
 }
 
-void Controller::SetTextFitStepSize( float step, FontSizeType type )
+void Controller::SetTextFitStepSize(float step, FontSizeType type)
 {
-  switch( type )
+  switch(type)
   {
     case POINT_SIZE:
     {
@@ -513,7 +506,7 @@ void Controller::SetTextFitStepSize( float step, FontSizeType type )
     }
     case PIXEL_SIZE:
     {
-      mImpl->mTextFitStepSize = ConvertPixelToPint( step );
+      mImpl->mTextFitStepSize = ConvertPixelToPint(step);
       break;
     }
   }
@@ -534,7 +527,7 @@ Vector2 Controller::GetTextFitContentSize() const
   return mImpl->mTextFitContentSize;
 }
 
-void Controller::SetPlaceholderTextElideEnabled( bool enabled )
+void Controller::SetPlaceholderTextElideEnabled(bool enabled)
 {
   PlaceholderHandler::SetPlaceholderTextElideEnabled(*this, enabled);
 }
@@ -544,7 +537,7 @@ bool Controller::IsPlaceholderTextElideEnabled() const
   return PlaceholderHandler::IsPlaceholderTextElideEnabled(*this);
 }
 
-void Controller::SetSelectionEnabled( bool enabled )
+void Controller::SetSelectionEnabled(bool enabled)
 {
   mImpl->mEventData->mSelectionEnabled = enabled;
 }
@@ -554,7 +547,7 @@ bool Controller::IsSelectionEnabled() const
   return mImpl->mEventData->mSelectionEnabled;
 }
 
-void Controller::SetShiftSelectionEnabled( bool enabled )
+void Controller::SetShiftSelectionEnabled(bool enabled)
 {
   mImpl->mEventData->mShiftSelectionFlag = enabled;
 }
@@ -564,7 +557,7 @@ bool Controller::IsShiftSelectionEnabled() const
   return mImpl->mEventData->mShiftSelectionFlag;
 }
 
-void Controller::SetGrabHandleEnabled( bool enabled )
+void Controller::SetGrabHandleEnabled(bool enabled)
 {
   mImpl->mEventData->mGrabHandleEnabled = enabled;
 }
@@ -586,9 +579,9 @@ bool Controller::IsGrabHandlePopupEnabled() const
 
 // public : Update
 
-void Controller::SetText( const std::string& text )
+void Controller::SetText(const std::string& text)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText\n" );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::SetText\n");
 
   // Reset keyboard as text changed
   mImpl->ResetInputMethodContext();
@@ -601,55 +594,55 @@ void Controller::SetText( const std::string& text )
 
   CharacterIndex lastCursorIndex = 0u;
 
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     // If popup shown then hide it by switching to Editing state
-    if( ( EventData::SELECTING == mImpl->mEventData->mState )          ||
-        ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) ||
-        ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) ||
-        ( EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState ) )
+    if((EventData::SELECTING == mImpl->mEventData->mState) ||
+       (EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState) ||
+       (EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState) ||
+       (EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState))
     {
-      mImpl->ChangeState( EventData::EDITING );
+      mImpl->ChangeState(EventData::EDITING);
     }
   }
 
-  if( !text.empty() )
+  if(!text.empty())
   {
-    mImpl->mModel->mVisualModel->SetTextColor( mImpl->mTextColor );
+    mImpl->mModel->mVisualModel->SetTextColor(mImpl->mTextColor);
 
-    MarkupProcessData markupProcessData( mImpl->mModel->mLogicalModel->mColorRuns,
-                                         mImpl->mModel->mLogicalModel->mFontDescriptionRuns,
-                                         mImpl->mModel->mLogicalModel->mEmbeddedItems );
+    MarkupProcessData markupProcessData(mImpl->mModel->mLogicalModel->mColorRuns,
+                                        mImpl->mModel->mLogicalModel->mFontDescriptionRuns,
+                                        mImpl->mModel->mLogicalModel->mEmbeddedItems);
 
-    Length textSize = 0u;
-    const uint8_t* utf8 = NULL;
-    if( mImpl->mMarkupProcessorEnabled )
+    Length         textSize = 0u;
+    const uint8_t* utf8     = NULL;
+    if(mImpl->mMarkupProcessorEnabled)
     {
-      ProcessMarkupString( text, markupProcessData );
+      ProcessMarkupString(text, markupProcessData);
       textSize = markupProcessData.markupProcessedText.size();
 
       // This is a bit horrible but std::string returns a (signed) char*
-      utf8 = reinterpret_cast<const uint8_t*>( markupProcessData.markupProcessedText.c_str() );
+      utf8 = reinterpret_cast<const uint8_t*>(markupProcessData.markupProcessedText.c_str());
     }
     else
     {
       textSize = text.size();
 
       // This is a bit horrible but std::string returns a (signed) char*
-      utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
+      utf8 = reinterpret_cast<const uint8_t*>(text.c_str());
     }
 
     //  Convert text into UTF-32
     Vector<Character>& utf32Characters = mImpl->mModel->mLogicalModel->mText;
-    utf32Characters.Resize( textSize );
+    utf32Characters.Resize(textSize);
 
     // Transform a text array encoded in utf8 into an array encoded in utf32.
     // It returns the actual number of characters.
-    Length characterCount = Utf8ToUtf32( utf8, textSize, utf32Characters.Begin() );
-    utf32Characters.Resize( characterCount );
+    Length characterCount = Utf8ToUtf32(utf8, textSize, utf32Characters.Begin());
+    utf32Characters.Resize(characterCount);
 
-    DALI_ASSERT_DEBUG( textSize >= characterCount && "Invalid UTF32 conversion length" );
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText %p UTF8 size %d, UTF32 size %d\n", this, textSize, mImpl->mModel->mLogicalModel->mText.Count() );
+    DALI_ASSERT_DEBUG(textSize >= characterCount && "Invalid UTF32 conversion length");
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::SetText %p UTF8 size %d, UTF32 size %d\n", this, textSize, mImpl->mModel->mLogicalModel->mText.Count());
 
     // The characters to be added.
     mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
@@ -658,7 +651,7 @@ void Controller::SetText( const std::string& text )
     lastCursorIndex = characterCount;
 
     // Update the rest of the model during size negotiation
-    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
+    mImpl->QueueModifyEvent(ModifyEvent::TEXT_REPLACED);
 
     // The natural size needs to be re-calculated.
     mImpl->mRecalculateNaturalSize = true;
@@ -675,56 +668,56 @@ void Controller::SetText( const std::string& text )
   }
 
   // Resets the cursor position.
-  ResetCursorPosition( lastCursorIndex );
+  ResetCursorPosition(lastCursorIndex);
 
   // Scrolls the text to make the cursor visible.
   ResetScrollPosition();
 
   mImpl->RequestRelayout();
 
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     // Cancel previously queued events
     mImpl->mEventData->mEventQueue.clear();
   }
 
   // Do this last since it provides callbacks into application code.
-  if( NULL != mImpl->mEditableControlInterface )
+  if(NULL != mImpl->mEditableControlInterface)
   {
-    mImpl->mEditableControlInterface->TextChanged();
+    mImpl->mEditableControlInterface->TextChanged(true);
   }
 }
 
-void Controller::GetText( std::string& text ) const
+void Controller::GetText(std::string& text) const
 {
-  if( !mImpl->IsShowingPlaceholderText() )
+  if(!mImpl->IsShowingPlaceholderText())
   {
     // Retrieves the text string.
-    mImpl->GetText( 0u, text );
+    mImpl->GetText(0u, text);
   }
   else
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this);
   }
 }
 
-void Controller::SetPlaceholderText( PlaceholderType type, const std::string& text )
+void Controller::SetPlaceholderText(PlaceholderType type, const std::string& text)
 {
   PlaceholderHandler::SetPlaceholderText(*this, type, text);
 }
 
-void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
+void Controller::GetPlaceholderText(PlaceholderType type, std::string& text) const
 {
-  PlaceholderHandler::GetPlaceholderText(*this, type, text );
+  PlaceholderHandler::GetPlaceholderText(*this, type, text);
 }
 
-void Controller::UpdateAfterFontChange( const std::string& newDefaultFont )
+void Controller::UpdateAfterFontChange(const std::string& newDefaultFont)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::UpdateAfterFontChange\n");
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::UpdateAfterFontChange\n");
 
-  if( !mImpl->mFontDefaults->familyDefined ) // If user defined font then should not update when system font changes
+  if(!mImpl->mFontDefaults->familyDefined) // If user defined font then should not update when system font changes
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Concise, "Controller::UpdateAfterFontChange newDefaultFont(%s)\n", newDefaultFont.c_str() );
+    DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::UpdateAfterFontChange newDefaultFont(%s)\n", newDefaultFont.c_str());
     mImpl->mFontDefaults->mFontDescription.family = newDefaultFont;
 
     ClearFontData();
@@ -735,23 +728,23 @@ void Controller::UpdateAfterFontChange( const std::string& newDefaultFont )
 
 // public : Default style & Input style
 
-void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
+void Controller::SetDefaultFontFamily(const std::string& defaultFontFamily)
 {
-  if( NULL == mImpl->mFontDefaults )
+  if(NULL == mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mFontDescription.family = defaultFontFamily;
-  DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
+  DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
   mImpl->mFontDefaults->familyDefined = !defaultFontFamily.empty();
 
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
     // Update the cursor position if it's in editing mode
-    if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
-      mImpl->mEventData->mDecoratorUpdated = true;
+      mImpl->mEventData->mDecoratorUpdated     = true;
       mImpl->mEventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font family is updated.
     }
   }
@@ -764,7 +757,7 @@ void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
 
 const std::string& Controller::GetDefaultFontFamily() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->mFontDescription.family;
   }
@@ -772,7 +765,7 @@ const std::string& Controller::GetDefaultFontFamily() const
   return EMPTY_STRING;
 }
 
-void Controller::SetPlaceholderFontFamily( const std::string& placeholderTextFontFamily )
+void Controller::SetPlaceholderFontFamily(const std::string& placeholderTextFontFamily)
 {
   PlaceholderHandler::SetPlaceholderFontFamily(*this, placeholderTextFontFamily);
 }
@@ -782,22 +775,22 @@ const std::string& Controller::GetPlaceholderFontFamily() const
   return PlaceholderHandler::GetPlaceholderFontFamily(*this);
 }
 
-void Controller::SetDefaultFontWeight( FontWeight weight )
+void Controller::SetDefaultFontWeight(FontWeight weight)
 {
-  if( NULL == mImpl->mFontDefaults )
+  if(NULL == mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mFontDescription.weight = weight;
-  mImpl->mFontDefaults->weightDefined = true;
+  mImpl->mFontDefaults->weightDefined           = true;
 
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
     // Update the cursor position if it's in editing mode
-    if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
-      mImpl->mEventData->mDecoratorUpdated = true;
+      mImpl->mEventData->mDecoratorUpdated     = true;
       mImpl->mEventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font weight is updated.
     }
   }
@@ -810,7 +803,7 @@ void Controller::SetDefaultFontWeight( FontWeight weight )
 
 bool Controller::IsDefaultFontWeightDefined() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->weightDefined;
   }
@@ -820,7 +813,7 @@ bool Controller::IsDefaultFontWeightDefined() const
 
 FontWeight Controller::GetDefaultFontWeight() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->mFontDescription.weight;
   }
@@ -828,14 +821,15 @@ FontWeight Controller::GetDefaultFontWeight() const
   return TextAbstraction::FontWeight::NORMAL;
 }
 
-void Controller::SetPlaceholderTextFontWeight( FontWeight weight )
+void Controller::SetPlaceholderTextFontWeight(FontWeight weight)
 {
   PlaceholderHandler::SetPlaceholderTextFontWeight(*this, weight);
 }
 
 bool Controller::IsPlaceholderTextFontWeightDefined() const
 {
-  return PlaceholderHandler::IsPlaceholderTextFontWeightDefined(*this);;
+  return PlaceholderHandler::IsPlaceholderTextFontWeightDefined(*this);
+  ;
 }
 
 FontWeight Controller::GetPlaceholderTextFontWeight() const
@@ -843,22 +837,22 @@ FontWeight Controller::GetPlaceholderTextFontWeight() const
   return PlaceholderHandler::GetPlaceholderTextFontWeight(*this);
 }
 
-void Controller::SetDefaultFontWidth( FontWidth width )
+void Controller::SetDefaultFontWidth(FontWidth width)
 {
-  if( NULL == mImpl->mFontDefaults )
+  if(NULL == mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mFontDescription.width = width;
-  mImpl->mFontDefaults->widthDefined = true;
+  mImpl->mFontDefaults->widthDefined           = true;
 
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
     // Update the cursor position if it's in editing mode
-    if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
-      mImpl->mEventData->mDecoratorUpdated = true;
+      mImpl->mEventData->mDecoratorUpdated     = true;
       mImpl->mEventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font width is updated.
     }
   }
@@ -871,7 +865,7 @@ void Controller::SetDefaultFontWidth( FontWidth width )
 
 bool Controller::IsDefaultFontWidthDefined() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->widthDefined;
   }
@@ -881,7 +875,7 @@ bool Controller::IsDefaultFontWidthDefined() const
 
 FontWidth Controller::GetDefaultFontWidth() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->mFontDescription.width;
   }
@@ -889,7 +883,7 @@ FontWidth Controller::GetDefaultFontWidth() const
   return TextAbstraction::FontWidth::NORMAL;
 }
 
-void Controller::SetPlaceholderTextFontWidth( FontWidth width )
+void Controller::SetPlaceholderTextFontWidth(FontWidth width)
 {
   PlaceholderHandler::SetPlaceholderTextFontWidth(*this, width);
 }
@@ -904,22 +898,22 @@ FontWidth Controller::GetPlaceholderTextFontWidth() const
   return PlaceholderHandler::GetPlaceholderTextFontWidth(*this);
 }
 
-void Controller::SetDefaultFontSlant( FontSlant slant )
+void Controller::SetDefaultFontSlant(FontSlant slant)
 {
-  if( NULL == mImpl->mFontDefaults )
+  if(NULL == mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults = new FontDefaults();
   }
 
   mImpl->mFontDefaults->mFontDescription.slant = slant;
-  mImpl->mFontDefaults->slantDefined = true;
+  mImpl->mFontDefaults->slantDefined           = true;
 
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
     // Update the cursor position if it's in editing mode
-    if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
-      mImpl->mEventData->mDecoratorUpdated = true;
+      mImpl->mEventData->mDecoratorUpdated     = true;
       mImpl->mEventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font slant is updated.
     }
   }
@@ -932,7 +926,7 @@ void Controller::SetDefaultFontSlant( FontSlant slant )
 
 bool Controller::IsDefaultFontSlantDefined() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->slantDefined;
   }
@@ -941,7 +935,7 @@ bool Controller::IsDefaultFontSlantDefined() const
 
 FontSlant Controller::GetDefaultFontSlant() const
 {
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
     return mImpl->mFontDefaults->mFontDescription.slant;
   }
@@ -949,7 +943,7 @@ FontSlant Controller::GetDefaultFontSlant() const
   return TextAbstraction::FontSlant::NORMAL;
 }
 
-void Controller::SetPlaceholderTextFontSlant( FontSlant slant )
+void Controller::SetPlaceholderTextFontSlant(FontSlant slant)
 {
   PlaceholderHandler::SetPlaceholderTextFontSlant(*this, slant);
 }
@@ -964,41 +958,41 @@ FontSlant Controller::GetPlaceholderTextFontSlant() const
   return PlaceholderHandler::GetPlaceholderTextFontSlant(*this);
 }
 
-void Controller::SetDefaultFontSize( float fontSize, FontSizeType type )
+void Controller::SetDefaultFontSize(float fontSize, FontSizeType type)
 {
-  if( NULL == mImpl->mFontDefaults )
+  if(NULL == mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults = new FontDefaults();
   }
 
-  switch( type )
+  switch(type)
   {
     case POINT_SIZE:
     {
       mImpl->mFontDefaults->mDefaultPointSize = fontSize;
-      mImpl->mFontDefaults->sizeDefined = true;
+      mImpl->mFontDefaults->sizeDefined       = true;
       break;
     }
     case PIXEL_SIZE:
     {
       // Point size = Pixel size * 72.f / DPI
-      unsigned int horizontalDpi = 0u;
-      unsigned int verticalDpi = 0u;
-      TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
-      fontClient.GetDpi( horizontalDpi, verticalDpi );
+      unsigned int                horizontalDpi = 0u;
+      unsigned int                verticalDpi   = 0u;
+      TextAbstraction::FontClient fontClient    = TextAbstraction::FontClient::Get();
+      fontClient.GetDpi(horizontalDpi, verticalDpi);
 
-      mImpl->mFontDefaults->mDefaultPointSize = ( fontSize * 72.f ) / static_cast< float >( horizontalDpi );
-      mImpl->mFontDefaults->sizeDefined = true;
+      mImpl->mFontDefaults->mDefaultPointSize = (fontSize * 72.f) / static_cast<float>(horizontalDpi);
+      mImpl->mFontDefaults->sizeDefined       = true;
       break;
     }
   }
 
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
     // Update the cursor position if it's in editing mode
-    if( EventData::IsEditingState( mImpl->mEventData->mState ) )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
-      mImpl->mEventData->mDecoratorUpdated = true;
+      mImpl->mEventData->mDecoratorUpdated     = true;
       mImpl->mEventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font size is updated.
     }
   }
@@ -1009,12 +1003,12 @@ void Controller::SetDefaultFontSize( float fontSize, FontSizeType type )
   mImpl->RequestRelayout();
 }
 
-float Controller::GetDefaultFontSize( FontSizeType type ) const
+float Controller::GetDefaultFontSize(FontSizeType type) const
 {
   float value = 0.0f;
-  if( NULL != mImpl->mFontDefaults )
+  if(NULL != mImpl->mFontDefaults)
   {
-    switch( type )
+    switch(type)
     {
       case POINT_SIZE:
       {
@@ -1024,12 +1018,12 @@ float Controller::GetDefaultFontSize( FontSizeType type ) const
       case PIXEL_SIZE:
       {
         // Pixel size = Point size * DPI / 72.f
-        unsigned int horizontalDpi = 0u;
-        unsigned int verticalDpi = 0u;
-        TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
-        fontClient.GetDpi( horizontalDpi, verticalDpi );
+        unsigned int                horizontalDpi = 0u;
+        unsigned int                verticalDpi   = 0u;
+        TextAbstraction::FontClient fontClient    = TextAbstraction::FontClient::Get();
+        fontClient.GetDpi(horizontalDpi, verticalDpi);
 
-        value = mImpl->mFontDefaults->mDefaultPointSize * static_cast< float >( horizontalDpi ) / 72.f;
+        value = mImpl->mFontDefaults->mDefaultPointSize * static_cast<float>(horizontalDpi) / 72.f;
         break;
       }
     }
@@ -1039,27 +1033,27 @@ float Controller::GetDefaultFontSize( FontSizeType type ) const
   return value;
 }
 
-void Controller::SetPlaceholderTextFontSize( float fontSize, FontSizeType type )
+void Controller::SetPlaceholderTextFontSize(float fontSize, FontSizeType type)
 {
   PlaceholderHandler::SetPlaceholderTextFontSize(*this, fontSize, type);
 }
 
-float Controller::GetPlaceholderTextFontSize( FontSizeType type ) const
+float Controller::GetPlaceholderTextFontSize(FontSizeType type) const
 {
   return PlaceholderHandler::GetPlaceholderTextFontSize(*this, type);
 }
 
-void Controller::SetDefaultColor( const Vector4& color )
+void Controller::SetDefaultColor(const Vector4& color)
 {
   mImpl->mTextColor = color;
 
-  if( !mImpl->IsShowingPlaceholderText() )
+  if(!mImpl->IsShowingPlaceholderText())
   {
-    mImpl->mModel->mVisualModel->SetTextColor( color );
+    mImpl->mModel->mVisualModel->SetTextColor(color);
 
     mImpl->mModel->mLogicalModel->mColorRuns.Clear();
 
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | COLOR );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | COLOR);
 
     mImpl->RequestRelayout();
   }
@@ -1070,7 +1064,7 @@ const Vector4& Controller::GetDefaultColor() const
   return mImpl->mTextColor;
 }
 
-void Controller::SetPlaceholderTextColor( const Vector4& textColor )
+void Controller::SetPlaceholderTextColor(const Vector4& textColor)
 {
   PlaceholderHandler::SetPlaceholderTextColor(*this, textColor);
 }
@@ -1080,9 +1074,9 @@ const Vector4& Controller::GetPlaceholderTextColor() const
   return PlaceholderHandler::GetPlaceholderTextColor(*this);
 }
 
-void Controller::SetShadowOffset( const Vector2& shadowOffset )
+void Controller::SetShadowOffset(const Vector2& shadowOffset)
 {
-  mImpl->mModel->mVisualModel->SetShadowOffset( shadowOffset );
+  mImpl->mModel->mVisualModel->SetShadowOffset(shadowOffset);
 
   mImpl->RequestRelayout();
 }
@@ -1092,9 +1086,9 @@ const Vector2& Controller::GetShadowOffset() const
   return mImpl->mModel->mVisualModel->GetShadowOffset();
 }
 
-void Controller::SetShadowColor( const Vector4& shadowColor )
+void Controller::SetShadowColor(const Vector4& shadowColor)
 {
-  mImpl->mModel->mVisualModel->SetShadowColor( shadowColor );
+  mImpl->mModel->mVisualModel->SetShadowColor(shadowColor);
 
   mImpl->RequestRelayout();
 }
@@ -1104,11 +1098,11 @@ const Vector4& Controller::GetShadowColor() const
   return mImpl->mModel->mVisualModel->GetShadowColor();
 }
 
-void Controller::SetShadowBlurRadius( const float& shadowBlurRadius )
+void Controller::SetShadowBlurRadius(const float& shadowBlurRadius)
 {
-  if ( fabsf( GetShadowBlurRadius() - shadowBlurRadius ) > Math::MACHINE_EPSILON_1 )
+  if(fabsf(GetShadowBlurRadius() - shadowBlurRadius) > Math::MACHINE_EPSILON_1)
   {
-    mImpl->mModel->mVisualModel->SetShadowBlurRadius( shadowBlurRadius );
+    mImpl->mModel->mVisualModel->SetShadowBlurRadius(shadowBlurRadius);
 
     mImpl->RequestRelayout();
   }
@@ -1119,9 +1113,9 @@ const float& Controller::GetShadowBlurRadius() const
   return mImpl->mModel->mVisualModel->GetShadowBlurRadius();
 }
 
-void Controller::SetUnderlineColor( const Vector4& color )
+void Controller::SetUnderlineColor(const Vector4& color)
 {
-  mImpl->mModel->mVisualModel->SetUnderlineColor( color );
+  mImpl->mModel->mVisualModel->SetUnderlineColor(color);
 
   mImpl->RequestRelayout();
 }
@@ -1131,9 +1125,9 @@ const Vector4& Controller::GetUnderlineColor() const
   return mImpl->mModel->mVisualModel->GetUnderlineColor();
 }
 
-void Controller::SetUnderlineEnabled( bool enabled )
+void Controller::SetUnderlineEnabled(bool enabled)
 {
-  mImpl->mModel->mVisualModel->SetUnderlineEnabled( enabled );
+  mImpl->mModel->mVisualModel->SetUnderlineEnabled(enabled);
 
   mImpl->RequestRelayout();
 }
@@ -1143,9 +1137,9 @@ bool Controller::IsUnderlineEnabled() const
   return mImpl->mModel->mVisualModel->IsUnderlineEnabled();
 }
 
-void Controller::SetUnderlineHeight( float height )
+void Controller::SetUnderlineHeight(float height)
 {
-  mImpl->mModel->mVisualModel->SetUnderlineHeight( height );
+  mImpl->mModel->mVisualModel->SetUnderlineHeight(height);
 
   mImpl->RequestRelayout();
 }
@@ -1155,9 +1149,9 @@ float Controller::GetUnderlineHeight() const
   return mImpl->mModel->mVisualModel->GetUnderlineHeight();
 }
 
-void Controller::SetOutlineColor( const Vector4& color )
+void Controller::SetOutlineColor(const Vector4& color)
 {
-  mImpl->mModel->mVisualModel->SetOutlineColor( color );
+  mImpl->mModel->mVisualModel->SetOutlineColor(color);
 
   mImpl->RequestRelayout();
 }
@@ -1167,9 +1161,9 @@ const Vector4& Controller::GetOutlineColor() const
   return mImpl->mModel->mVisualModel->GetOutlineColor();
 }
 
-void Controller::SetOutlineWidth( uint16_t width )
+void Controller::SetOutlineWidth(uint16_t width)
 {
-  mImpl->mModel->mVisualModel->SetOutlineWidth( width );
+  mImpl->mModel->mVisualModel->SetOutlineWidth(width);
 
   mImpl->RequestRelayout();
 }
@@ -1179,9 +1173,9 @@ uint16_t Controller::GetOutlineWidth() const
   return mImpl->mModel->mVisualModel->GetOutlineWidth();
 }
 
-void Controller::SetBackgroundColor( const Vector4& color )
+void Controller::SetBackgroundColor(const Vector4& color)
 {
-  mImpl->mModel->mVisualModel->SetBackgroundColor( color );
+  mImpl->mModel->mVisualModel->SetBackgroundColor(color);
 
   mImpl->RequestRelayout();
 }
@@ -1191,9 +1185,9 @@ const Vector4& Controller::GetBackgroundColor() const
   return mImpl->mModel->mVisualModel->GetBackgroundColor();
 }
 
-void Controller::SetBackgroundEnabled( bool enabled )
+void Controller::SetBackgroundEnabled(bool enabled)
 {
-  mImpl->mModel->mVisualModel->SetBackgroundEnabled( enabled );
+  mImpl->mModel->mVisualModel->SetBackgroundEnabled(enabled);
 
   mImpl->RequestRelayout();
 }
@@ -1203,9 +1197,9 @@ bool Controller::IsBackgroundEnabled() const
   return mImpl->mModel->mVisualModel->IsBackgroundEnabled();
 }
 
-void Controller::SetDefaultEmbossProperties( const std::string& embossProperties )
+void Controller::SetDefaultEmbossProperties(const std::string& embossProperties)
 {
-  if( NULL == mImpl->mEmbossDefaults )
+  if(NULL == mImpl->mEmbossDefaults)
   {
     mImpl->mEmbossDefaults = new EmbossDefaults();
   }
@@ -1215,7 +1209,7 @@ void Controller::SetDefaultEmbossProperties( const std::string& embossProperties
 
 const std::string& Controller::GetDefaultEmbossProperties() const
 {
-  if( NULL != mImpl->mEmbossDefaults )
+  if(NULL != mImpl->mEmbossDefaults)
   {
     return mImpl->mEmbossDefaults->properties;
   }
@@ -1223,9 +1217,9 @@ const std::string& Controller::GetDefaultEmbossProperties() const
   return EMPTY_STRING;
 }
 
-void Controller::SetDefaultOutlineProperties( const std::string& outlineProperties )
+void Controller::SetDefaultOutlineProperties(const std::string& outlineProperties)
 {
-  if( NULL == mImpl->mOutlineDefaults )
+  if(NULL == mImpl->mOutlineDefaults)
   {
     mImpl->mOutlineDefaults = new OutlineDefaults();
   }
@@ -1235,7 +1229,7 @@ void Controller::SetDefaultOutlineProperties( const std::string& outlineProperti
 
 const std::string& Controller::GetDefaultOutlineProperties() const
 {
-  if( NULL != mImpl->mOutlineDefaults )
+  if(NULL != mImpl->mOutlineDefaults)
   {
     return mImpl->mOutlineDefaults->properties;
   }
@@ -1243,9 +1237,9 @@ const std::string& Controller::GetDefaultOutlineProperties() const
   return EMPTY_STRING;
 }
 
-bool Controller::SetDefaultLineSpacing( float lineSpacing )
+bool Controller::SetDefaultLineSpacing(float lineSpacing)
 {
-  if( std::fabs( lineSpacing - mImpl->mLayoutEngine.GetDefaultLineSpacing() ) > Math::MACHINE_EPSILON_1000 )
+  if(std::fabs(lineSpacing - mImpl->mLayoutEngine.GetDefaultLineSpacing()) > Math::MACHINE_EPSILON_1000)
   {
     mImpl->mLayoutEngine.SetDefaultLineSpacing(lineSpacing);
     mImpl->mRecalculateNaturalSize = true;
@@ -1259,9 +1253,9 @@ float Controller::GetDefaultLineSpacing() const
   return mImpl->mLayoutEngine.GetDefaultLineSpacing();
 }
 
-bool Controller::SetDefaultLineSize( float lineSize )
+bool Controller::SetDefaultLineSize(float lineSize)
 {
-  if( std::fabs( lineSize - mImpl->mLayoutEngine.GetDefaultLineSize() ) > Math::MACHINE_EPSILON_1000 )
+  if(std::fabs(lineSize - mImpl->mLayoutEngine.GetDefaultLineSize()) > Math::MACHINE_EPSILON_1000)
   {
     mImpl->mLayoutEngine.SetDefaultLineSize(lineSize);
     mImpl->mRecalculateNaturalSize = true;
@@ -1275,54 +1269,53 @@ float Controller::GetDefaultLineSize() const
   return mImpl->mLayoutEngine.GetDefaultLineSize();
 }
 
-void Controller::SetInputColor( const Vector4& color )
+void Controller::SetInputColor(const Vector4& color)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
-    mImpl->mEventData->mInputStyle.textColor = color;
+    mImpl->mEventData->mInputStyle.textColor      = color;
     mImpl->mEventData->mInputStyle.isDefaultColor = false;
 
-    if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
+    if(EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState)
     {
       const bool handlesCrossed = mImpl->mEventData->mLeftSelectionPosition > mImpl->mEventData->mRightSelectionPosition;
 
       // Get start and end position of selection
-      const CharacterIndex startOfSelectedText = handlesCrossed ? mImpl->mEventData->mRightSelectionPosition : mImpl->mEventData->mLeftSelectionPosition;
-      const Length lengthOfSelectedText = ( handlesCrossed ? mImpl->mEventData->mLeftSelectionPosition : mImpl->mEventData->mRightSelectionPosition ) - startOfSelectedText;
+      const CharacterIndex startOfSelectedText  = handlesCrossed ? mImpl->mEventData->mRightSelectionPosition : mImpl->mEventData->mLeftSelectionPosition;
+      const Length         lengthOfSelectedText = (handlesCrossed ? mImpl->mEventData->mLeftSelectionPosition : mImpl->mEventData->mRightSelectionPosition) - startOfSelectedText;
 
       // Add the color run.
       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mColorRuns.Count();
-      mImpl->mModel->mLogicalModel->mColorRuns.Resize( numberOfRuns + 1u );
+      mImpl->mModel->mLogicalModel->mColorRuns.Resize(numberOfRuns + 1u);
 
-      ColorRun& colorRun = *( mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns );
-      colorRun.color = color;
-      colorRun.characterRun.characterIndex = startOfSelectedText;
+      ColorRun& colorRun                       = *(mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns);
+      colorRun.color                           = color;
+      colorRun.characterRun.characterIndex     = startOfSelectedText;
       colorRun.characterRun.numberOfCharacters = lengthOfSelectedText;
 
       // Request to relayout.
-      mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | COLOR );
+      mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | COLOR);
       mImpl->RequestRelayout();
 
-      mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
+      mImpl->mTextUpdateInfo.mCharacterIndex             = startOfSelectedText;
       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
-      mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
+      mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = lengthOfSelectedText;
     }
   }
 }
 
 const Vector4& Controller::GetInputColor() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.textColor;
   }
 
   // Return the default text's color if there is no EventData.
   return mImpl->mTextColor;
-
 }
 
-void Controller::SetInputFontFamily( const std::string& fontFamily )
+void Controller::SetInputFontFamily(const std::string& fontFamily)
 {
   InputFontHandler::SetInputFontFamily(*this, fontFamily);
 }
@@ -1332,7 +1325,7 @@ const std::string& Controller::GetInputFontFamily() const
   return InputFontHandler::GetInputFontFamily(*this);
 }
 
-void Controller::SetInputFontWeight( FontWeight weight )
+void Controller::SetInputFontWeight(FontWeight weight)
 {
   InputFontHandler::SetInputFontWeight(*this, weight);
 }
@@ -1347,7 +1340,7 @@ FontWeight Controller::GetInputFontWeight() const
   return InputFontHandler::GetInputFontWeight(*this);
 }
 
-void Controller::SetInputFontWidth( FontWidth width )
+void Controller::SetInputFontWidth(FontWidth width)
 {
   InputFontHandler::SetInputFontWidth(*this, width);
 }
@@ -1362,7 +1355,7 @@ FontWidth Controller::GetInputFontWidth() const
   return InputFontHandler::GetInputFontWidth(*this);
 }
 
-void Controller::SetInputFontSlant( FontSlant slant )
+void Controller::SetInputFontSlant(FontSlant slant)
 {
   InputFontHandler::SetInputFontSlant(*this, slant);
 }
@@ -1377,7 +1370,7 @@ FontSlant Controller::GetInputFontSlant() const
   return InputFontHandler::GetInputFontSlant(*this);
 }
 
-void Controller::SetInputFontPointSize( float size )
+void Controller::SetInputFontPointSize(float size)
 {
   InputFontHandler::SetInputFontPointSize(*this, size);
 }
@@ -1387,18 +1380,18 @@ float Controller::GetInputFontPointSize() const
   return InputFontHandler::GetInputFontPointSize(*this);
 }
 
-void Controller::SetInputLineSpacing( float lineSpacing )
+void Controller::SetInputLineSpacing(float lineSpacing)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
-    mImpl->mEventData->mInputStyle.lineSpacing = lineSpacing;
+    mImpl->mEventData->mInputStyle.lineSpacing          = lineSpacing;
     mImpl->mEventData->mInputStyle.isLineSpacingDefined = true;
   }
 }
 
 float Controller::GetInputLineSpacing() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.lineSpacing;
   }
@@ -1406,9 +1399,9 @@ float Controller::GetInputLineSpacing() const
   return 0.f;
 }
 
-void Controller::SetInputShadowProperties( const std::string& shadowProperties )
+void Controller::SetInputShadowProperties(const std::string& shadowProperties)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mInputStyle.shadowProperties = shadowProperties;
   }
@@ -1416,7 +1409,7 @@ void Controller::SetInputShadowProperties( const std::string& shadowProperties )
 
 const std::string& Controller::GetInputShadowProperties() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.shadowProperties;
   }
@@ -1424,9 +1417,9 @@ const std::string& Controller::GetInputShadowProperties() const
   return EMPTY_STRING;
 }
 
-void Controller::SetInputUnderlineProperties( const std::string& underlineProperties )
+void Controller::SetInputUnderlineProperties(const std::string& underlineProperties)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mInputStyle.underlineProperties = underlineProperties;
   }
@@ -1434,7 +1427,7 @@ void Controller::SetInputUnderlineProperties( const std::string& underlineProper
 
 const std::string& Controller::GetInputUnderlineProperties() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.underlineProperties;
   }
@@ -1442,9 +1435,9 @@ const std::string& Controller::GetInputUnderlineProperties() const
   return EMPTY_STRING;
 }
 
-void Controller::SetInputEmbossProperties( const std::string& embossProperties )
+void Controller::SetInputEmbossProperties(const std::string& embossProperties)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mInputStyle.embossProperties = embossProperties;
   }
@@ -1452,7 +1445,7 @@ void Controller::SetInputEmbossProperties( const std::string& embossProperties )
 
 const std::string& Controller::GetInputEmbossProperties() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.embossProperties;
   }
@@ -1460,9 +1453,9 @@ const std::string& Controller::GetInputEmbossProperties() const
   return GetDefaultEmbossProperties();
 }
 
-void Controller::SetInputOutlineProperties( const std::string& outlineProperties )
+void Controller::SetInputOutlineProperties(const std::string& outlineProperties)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mInputStyle.outlineProperties = outlineProperties;
   }
@@ -1470,7 +1463,7 @@ void Controller::SetInputOutlineProperties( const std::string& outlineProperties
 
 const std::string& Controller::GetInputOutlineProperties() const
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mInputStyle.outlineProperties;
   }
@@ -1478,9 +1471,9 @@ const std::string& Controller::GetInputOutlineProperties() const
   return GetDefaultOutlineProperties();
 }
 
-void Controller::SetInputModePassword( bool passwordInput )
+void Controller::SetInputModePassword(bool passwordInput)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mPasswordInput = passwordInput;
   }
@@ -1488,16 +1481,16 @@ void Controller::SetInputModePassword( bool passwordInput )
 
 bool Controller::IsInputModePassword()
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     return mImpl->mEventData->mPasswordInput;
   }
   return false;
 }
 
-void Controller::SetNoTextDoubleTapAction( NoTextTap::Action action )
+void Controller::SetNoTextDoubleTapAction(NoTextTap::Action action)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mDoubleTapAction = action;
   }
@@ -1507,7 +1500,7 @@ Controller::NoTextTap::Action Controller::GetNoTextDoubleTapAction() const
 {
   NoTextTap::Action action = NoTextTap::NO_ACTION;
 
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     action = mImpl->mEventData->mDoubleTapAction;
   }
@@ -1515,9 +1508,9 @@ Controller::NoTextTap::Action Controller::GetNoTextDoubleTapAction() const
   return action;
 }
 
-void Controller::SetNoTextLongPressAction( NoTextTap::Action action )
+void Controller::SetNoTextLongPressAction(NoTextTap::Action action)
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mLongPressAction = action;
   }
@@ -1527,7 +1520,7 @@ Controller::NoTextTap::Action Controller::GetNoTextLongPressAction() const
 {
   NoTextTap::Action action = NoTextTap::NO_ACTION;
 
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     action = mImpl->mEventData->mLongPressAction;
   }
@@ -1540,7 +1533,7 @@ bool Controller::IsUnderlineSetByString()
   return mImpl->mUnderlineSetByString;
 }
 
-void Controller::UnderlineSetByString( bool setByString )
+void Controller::UnderlineSetByString(bool setByString)
 {
   mImpl->mUnderlineSetByString = setByString;
 }
@@ -1550,7 +1543,7 @@ bool Controller::IsShadowSetByString()
   return mImpl->mShadowSetByString;
 }
 
-void Controller::ShadowSetByString( bool setByString )
+void Controller::ShadowSetByString(bool setByString)
 {
   mImpl->mShadowSetByString = setByString;
 }
@@ -1560,7 +1553,7 @@ bool Controller::IsOutlineSetByString()
   return mImpl->mOutlineSetByString;
 }
 
-void Controller::OutlineSetByString( bool setByString )
+void Controller::OutlineSetByString(bool setByString)
 {
   mImpl->mOutlineSetByString = setByString;
 }
@@ -1570,7 +1563,7 @@ bool Controller::IsFontStyleSetByString()
   return mImpl->mFontStyleSetByString;
 }
 
-void Controller::FontStyleSetByString( bool setByString )
+void Controller::FontStyleSetByString(bool setByString)
 {
   mImpl->mFontStyleSetByString = setByString;
 }
@@ -1589,53 +1582,53 @@ View& Controller::GetView()
 
 Vector3 Controller::GetNaturalSize()
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
+  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 )
+  if(mImpl->mRecalculateNaturalSize)
   {
     // 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   |
-                                                                           BIDI_INFO         |
-                                                                           SHAPE_TEXT        |
-                                                                           GET_GLYPH_METRICS );
+    const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(CONVERT_TO_UTF32 |
+                                                                          GET_SCRIPTS |
+                                                                          VALIDATE_FONTS |
+                                                                          GET_LINE_BREAKS |
+                                                                          BIDI_INFO |
+                                                                          SHAPE_TEXT |
+                                                                          GET_GLYPH_METRICS);
 
     // Set the update info to relayout the whole text.
-    mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mParagraphCharacterIndex     = 0u;
     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
 
     // Make sure the model is up-to-date before layouting
-    mImpl->UpdateModel( onlyOnceOperations );
+    mImpl->UpdateModel(onlyOnceOperations);
 
     // Layout the text for the new width.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | LAYOUT | REORDER );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | LAYOUT | REORDER);
 
     // Store the actual control's size to restore later.
     const Size actualControlSize = mImpl->mModel->mVisualModel->mControlSize;
 
-    DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
-                static_cast<OperationsMask>( onlyOnceOperations |
-                                             LAYOUT | REORDER ),
-                naturalSize.GetVectorXY() );
+    DoRelayout(Size(MAX_FLOAT, MAX_FLOAT),
+               static_cast<OperationsMask>(onlyOnceOperations |
+                                           LAYOUT | REORDER),
+               naturalSize.GetVectorXY());
 
     // Do not do again the only once operations.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending & ~onlyOnceOperations);
 
     // Do the size related operations again.
-    const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
-                                                                        ALIGN  |
-                                                                        REORDER );
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
+    const OperationsMask sizeOperations = static_cast<OperationsMask>(LAYOUT |
+                                                                      ALIGN |
+                                                                      REORDER);
+    mImpl->mOperationsPending           = static_cast<OperationsMask>(mImpl->mOperationsPending | sizeOperations);
 
     // Stores the natural size to avoid recalculate it again
     // unless the text/style changes.
-    mImpl->mModel->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
+    mImpl->mModel->mVisualModel->SetNaturalSize(naturalSize.GetVectorXY());
 
     mImpl->mRecalculateNaturalSize = false;
 
@@ -1646,160 +1639,159 @@ Vector3 Controller::GetNaturalSize()
     // Restore the actual control's size.
     mImpl->mModel->mVisualModel->mControlSize = actualControlSize;
 
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z);
   }
   else
   {
     naturalSize = mImpl->mModel->mVisualModel->GetNaturalSize();
 
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z);
   }
 
-  naturalSize.x = ConvertToEven( naturalSize.x );
-  naturalSize.y = ConvertToEven( naturalSize.y );
+  naturalSize.x = ConvertToEven(naturalSize.x);
+  naturalSize.y = ConvertToEven(naturalSize.y);
 
   return naturalSize;
 }
 
-bool Controller::CheckForTextFit( float pointSize, Size& layoutSize )
+bool Controller::CheckForTextFit(float pointSize, Size& layoutSize)
 {
   Size textSize;
   mImpl->mFontDefaults->mFitPointSize = pointSize;
-  mImpl->mFontDefaults->sizeDefined = true;
+  mImpl->mFontDefaults->sizeDefined   = true;
   ClearFontData();
 
   // 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 |
-                                                                                BIDI_INFO |
-                                                                                SHAPE_TEXT|
-                                                                         GET_GLYPH_METRICS );
-
-  mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
+  const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(CONVERT_TO_UTF32 |
+                                                                        GET_SCRIPTS |
+                                                                        VALIDATE_FONTS |
+                                                                        GET_LINE_BREAKS |
+                                                                        BIDI_INFO |
+                                                                        SHAPE_TEXT |
+                                                                        GET_GLYPH_METRICS);
+
+  mImpl->mTextUpdateInfo.mParagraphCharacterIndex     = 0u;
   mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
 
   // Make sure the model is up-to-date before layouting
-  mImpl->UpdateModel( onlyOnceOperations );
+  mImpl->UpdateModel(onlyOnceOperations);
 
-  DoRelayout( Size( layoutSize.width, MAX_FLOAT ),
-              static_cast<OperationsMask>( onlyOnceOperations | LAYOUT),
-              textSize);
+  DoRelayout(Size(layoutSize.width, MAX_FLOAT),
+             static_cast<OperationsMask>(onlyOnceOperations | LAYOUT),
+             textSize);
 
   // Clear the update info. This info will be set the next time the text is updated.
   mImpl->mTextUpdateInfo.Clear();
   mImpl->mTextUpdateInfo.mClearAll = true;
 
-  if( textSize.width > layoutSize.width || textSize.height > layoutSize.height )
+  if(textSize.width > layoutSize.width || textSize.height > layoutSize.height)
   {
     return false;
   }
   return true;
 }
 
-void Controller::FitPointSizeforLayout( Size layoutSize )
+void Controller::FitPointSizeforLayout(Size layoutSize)
 {
-  const OperationsMask operations  = mImpl->mOperationsPending;
-  if( NO_OPERATION != ( UPDATE_LAYOUT_SIZE & operations ) || mImpl->mTextFitContentSize != layoutSize )
+  const OperationsMask operations = mImpl->mOperationsPending;
+  if(NO_OPERATION != (UPDATE_LAYOUT_SIZE & operations) || mImpl->mTextFitContentSize != layoutSize)
   {
-    bool actualellipsis = mImpl->mModel->mElideEnabled;
-    float minPointSize = mImpl->mTextFitMinSize;
-    float maxPointSize = mImpl->mTextFitMaxSize;
-    float pointInterval = mImpl->mTextFitStepSize;
+    bool  actualellipsis = mImpl->mModel->mElideEnabled;
+    float minPointSize   = mImpl->mTextFitMinSize;
+    float maxPointSize   = mImpl->mTextFitMaxSize;
+    float pointInterval  = mImpl->mTextFitStepSize;
 
     mImpl->mModel->mElideEnabled = false;
     Vector<float> pointSizeArray;
 
     // check zero value
-    if( pointInterval < 1.f )
+    if(pointInterval < 1.f)
     {
       mImpl->mTextFitStepSize = pointInterval = 1.0f;
     }
 
-    pointSizeArray.Reserve( static_cast< unsigned int >( ceil( ( maxPointSize - minPointSize ) / pointInterval ) ) );
+    pointSizeArray.Reserve(static_cast<unsigned int>(ceil((maxPointSize - minPointSize) / pointInterval)));
 
-    for( float i = minPointSize; i < maxPointSize; i += pointInterval )
+    for(float i = minPointSize; i < maxPointSize; i += pointInterval)
     {
-      pointSizeArray.PushBack( i );
+      pointSizeArray.PushBack(i);
     }
 
-    pointSizeArray.PushBack( maxPointSize );
+    pointSizeArray.PushBack(maxPointSize);
 
     int bestSizeIndex = 0;
-    int min = bestSizeIndex + 1;
-    int max = pointSizeArray.Size() - 1;
-    while( min <= max )
+    int min           = bestSizeIndex + 1;
+    int max           = pointSizeArray.Size() - 1;
+    while(min <= max)
     {
-      int destI = ( min + max ) / 2;
+      int destI = (min + max) / 2;
 
-      if( CheckForTextFit( pointSizeArray[destI], layoutSize ) )
+      if(CheckForTextFit(pointSizeArray[destI], layoutSize))
       {
         bestSizeIndex = min;
-        min = destI + 1;
+        min           = destI + 1;
       }
       else
       {
-        max = destI - 1;
+        max           = destI - 1;
         bestSizeIndex = max;
       }
     }
 
-    mImpl->mModel->mElideEnabled = actualellipsis;
+    mImpl->mModel->mElideEnabled        = actualellipsis;
     mImpl->mFontDefaults->mFitPointSize = pointSizeArray[bestSizeIndex];
-    mImpl->mFontDefaults->sizeDefined = true;
+    mImpl->mFontDefaults->sizeDefined   = true;
     ClearFontData();
   }
 }
 
-float Controller::GetHeightForWidth( float width )
+float Controller::GetHeightForWidth(float width)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetHeightForWidth %p width %f\n", this, 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();
 
   Size layoutSize;
-  if( fabsf( width - mImpl->mModel->mVisualModel->mControlSize.width ) > Math::MACHINE_EPSILON_1000 ||
-                                                         mImpl->mTextUpdateInfo.mFullRelayoutNeeded ||
-                                                         mImpl->mTextUpdateInfo.mClearAll            )
+  if(fabsf(width - mImpl->mModel->mVisualModel->mControlSize.width) > Math::MACHINE_EPSILON_1000 ||
+     mImpl->mTextUpdateInfo.mFullRelayoutNeeded ||
+     mImpl->mTextUpdateInfo.mClearAll)
   {
     // 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   |
-                                                                           BIDI_INFO         |
-                                                                           SHAPE_TEXT        |
-                                                                           GET_GLYPH_METRICS );
+    const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(CONVERT_TO_UTF32 |
+                                                                          GET_SCRIPTS |
+                                                                          VALIDATE_FONTS |
+                                                                          GET_LINE_BREAKS |
+                                                                          BIDI_INFO |
+                                                                          SHAPE_TEXT |
+                                                                          GET_GLYPH_METRICS);
 
     // Set the update info to relayout the whole text.
-    mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mParagraphCharacterIndex     = 0u;
     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
 
     // Make sure the model is up-to-date before layouting
-    mImpl->UpdateModel( onlyOnceOperations );
-
+    mImpl->UpdateModel(onlyOnceOperations);
 
     // Layout the text for the new width.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | LAYOUT );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | LAYOUT);
 
     // Store the actual control's width.
     const float actualControlWidth = mImpl->mModel->mVisualModel->mControlSize.width;
 
-    DoRelayout( Size( width, MAX_FLOAT ),
-                static_cast<OperationsMask>( onlyOnceOperations |
-                                             LAYOUT ),
-                layoutSize );
+    DoRelayout(Size(width, MAX_FLOAT),
+               static_cast<OperationsMask>(onlyOnceOperations |
+                                           LAYOUT),
+               layoutSize);
 
     // Do not do again the only once operations.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending & ~onlyOnceOperations);
 
     // Do the size related operations again.
-    const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
-                                                                        ALIGN  |
-                                                                        REORDER );
+    const OperationsMask sizeOperations = static_cast<OperationsMask>(LAYOUT |
+                                                                      ALIGN |
+                                                                      REORDER);
 
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending | sizeOperations);
 
     // Clear the update info. This info will be set the next time the text is updated.
     mImpl->mTextUpdateInfo.Clear();
@@ -1808,20 +1800,20 @@ float Controller::GetHeightForWidth( float width )
     // Restore the actual control's width.
     mImpl->mModel->mVisualModel->mControlSize.width = actualControlWidth;
 
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height);
   }
   else
   {
     layoutSize = mImpl->mModel->mVisualModel->GetLayoutSize();
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth cached %f\n", layoutSize.height );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth cached %f\n", layoutSize.height);
   }
 
   return layoutSize.height;
 }
 
-int Controller::GetLineCount( float width )
+int Controller::GetLineCount(float width)
 {
-  GetHeightForWidth( width );
+  GetHeightForWidth(width);
   int numberofLines = mImpl->mModel->GetNumberOfLines();
   return numberofLines;
 }
@@ -1835,49 +1827,49 @@ float Controller::GetScrollAmountByUserInput()
 {
   float scrollAmount = 0.0f;
 
-  if (NULL != mImpl->mEventData && mImpl->mEventData->mCheckScrollAmount)
+  if(NULL != mImpl->mEventData && mImpl->mEventData->mCheckScrollAmount)
   {
-    scrollAmount = mImpl->mModel->mScrollPosition.y -  mImpl->mModel->mScrollPositionLast.y;
+    scrollAmount                          = mImpl->mModel->mScrollPosition.y - mImpl->mModel->mScrollPositionLast.y;
     mImpl->mEventData->mCheckScrollAmount = false;
   }
   return scrollAmount;
 }
 
-bool Controller::GetTextScrollInfo( float& scrollPosition, float& controlHeight, float& layoutHeight )
+bool Controller::GetTextScrollInfo(float& scrollPosition, float& controlHeight, float& layoutHeight)
 {
   const Vector2& layout = mImpl->mModel->mVisualModel->GetLayoutSize();
-  bool isScrolled;
+  bool           isScrolled;
 
-  controlHeight = mImpl->mModel->mVisualModel->mControlSize.height;
-  layoutHeight = layout.height;
+  controlHeight  = mImpl->mModel->mVisualModel->mControlSize.height;
+  layoutHeight   = layout.height;
   scrollPosition = mImpl->mModel->mScrollPosition.y;
-  isScrolled = !Equals( mImpl->mModel->mScrollPosition.y, mImpl->mModel->mScrollPositionLast.y, Math::MACHINE_EPSILON_1 );
+  isScrolled     = !Equals(mImpl->mModel->mScrollPosition.y, mImpl->mModel->mScrollPositionLast.y, Math::MACHINE_EPSILON_1);
   return isScrolled;
 }
 
-void Controller::SetHiddenInputOption(const Property::Map& options )
+void Controller::SetHiddenInputOption(const Property::Map& options)
 {
-  if( NULL == mImpl->mHiddenInput )
+  if(NULL == mImpl->mHiddenInput)
   {
-    mImpl->mHiddenInput = new HiddenText( this );
+    mImpl->mHiddenInput = new HiddenText(this);
   }
   mImpl->mHiddenInput->SetProperties(options);
 }
 
-void Controller::GetHiddenInputOption(Property::Map& options )
+void Controller::GetHiddenInputOption(Property::Map& options)
 {
-  if( NULL != mImpl->mHiddenInput )
+  if(NULL != mImpl->mHiddenInput)
   {
     mImpl->mHiddenInput->GetProperties(options);
   }
 }
 
-void Controller::SetPlaceholderProperty( const Property::Map& map )
+void Controller::SetPlaceholderProperty(const Property::Map& map)
 {
   PlaceholderHandler::SetPlaceholderProperty(*this, map);
 }
 
-void Controller::GetPlaceholderProperty( Property::Map& map )
+void Controller::GetPlaceholderProperty(Property::Map& map)
 {
   PlaceholderHandler::GetPlaceholderProperty(*this, map);
 }
@@ -1887,32 +1879,32 @@ Toolkit::DevelText::TextDirection::Type Controller::GetTextDirection()
   // Make sure the model is up-to-date before layouting
   ProcessModifyEvents();
 
-  if ( mImpl->mUpdateTextDirection )
+  if(mImpl->mUpdateTextDirection)
   {
     // 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   |
-                                                                           BIDI_INFO         |
-                                                                           SHAPE_TEXT        |
-                                                                           GET_GLYPH_METRICS );
+    const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(CONVERT_TO_UTF32 |
+                                                                          GET_SCRIPTS |
+                                                                          VALIDATE_FONTS |
+                                                                          GET_LINE_BREAKS |
+                                                                          BIDI_INFO |
+                                                                          SHAPE_TEXT |
+                                                                          GET_GLYPH_METRICS);
 
     // Set the update info to relayout the whole text.
-    mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mParagraphCharacterIndex     = 0u;
     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
 
     // Make sure the model is up-to-date before layouting
-    mImpl->UpdateModel( onlyOnceOperations );
+    mImpl->UpdateModel(onlyOnceOperations);
 
     Vector3 naturalSize;
-    DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
-                static_cast<OperationsMask>( onlyOnceOperations |
-                                             LAYOUT | REORDER | UPDATE_DIRECTION ),
-                naturalSize.GetVectorXY() );
+    DoRelayout(Size(MAX_FLOAT, MAX_FLOAT),
+               static_cast<OperationsMask>(onlyOnceOperations |
+                                           LAYOUT | REORDER | UPDATE_DIRECTION),
+               naturalSize.GetVectorXY());
 
     // Do not do again the only once operations.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending & ~onlyOnceOperations);
 
     // Clear the update info. This info will be set the next time the text is updated.
     mImpl->mTextUpdateInfo.Clear();
@@ -1931,22 +1923,22 @@ Toolkit::DevelText::VerticalLineAlignment::Type Controller::GetVerticalLineAlign
   return mImpl->mModel->GetVerticalLineAlignment();
 }
 
-void Controller::SetVerticalLineAlignment( Toolkit::DevelText::VerticalLineAlignment::Type alignment )
+void Controller::SetVerticalLineAlignment(Toolkit::DevelText::VerticalLineAlignment::Type alignment)
 {
   mImpl->mModel->mVerticalLineAlignment = alignment;
 }
 
 // public : Relayout.
 
-Controller::UpdateTextType Controller::Relayout( const Size& size, Dali::LayoutDirection::Type layoutDirection )
+Controller::UpdateTextType Controller::Relayout(const Size& size, Dali::LayoutDirection::Type layoutDirection)
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f, autoScroll[%s]\n", this, size.width, size.height, mImpl->mIsAutoScrollEnabled ?"true":"false"  );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f, autoScroll[%s]\n", this, size.width, size.height, mImpl->mIsAutoScrollEnabled ? "true" : "false");
 
   UpdateTextType updateTextType = NONE_UPDATED;
 
-  if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
+  if((size.width < Math::MACHINE_EPSILON_1000) || (size.height < Math::MACHINE_EPSILON_1000))
   {
-    if( 0u != mImpl->mModel->mVisualModel->mGlyphPositions.Count() )
+    if(0u != mImpl->mModel->mVisualModel->mGlyphPositions.Count())
     {
       mImpl->mModel->mVisualModel->mGlyphPositions.Clear();
       updateTextType = MODEL_UPDATED;
@@ -1956,95 +1948,95 @@ Controller::UpdateTextType Controller::Relayout( const Size& size, Dali::LayoutD
     mImpl->mTextUpdateInfo.Clear();
 
     // Not worth to relayout if width or height is equal to zero.
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n" );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n");
 
     return updateTextType;
   }
 
   // Whether a new size has been set.
-  const bool newSize = ( size != mImpl->mModel->mVisualModel->mControlSize );
+  const bool newSize = (size != mImpl->mModel->mVisualModel->mControlSize);
 
-  if( newSize )
+  if(newSize)
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mModel->mVisualModel->mControlSize.width, mImpl->mModel->mVisualModel->mControlSize.height );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mModel->mVisualModel->mControlSize.width, mImpl->mModel->mVisualModel->mControlSize.height);
 
-    if( ( 0 == mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd ) &&
-        ( 0 == mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters ) &&
-        ( ( mImpl->mModel->mVisualModel->mControlSize.width < Math::MACHINE_EPSILON_1000 ) || ( mImpl->mModel->mVisualModel->mControlSize.height < Math::MACHINE_EPSILON_1000 ) ) )
+    if((0 == mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd) &&
+       (0 == mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters) &&
+       ((mImpl->mModel->mVisualModel->mControlSize.width < Math::MACHINE_EPSILON_1000) || (mImpl->mModel->mVisualModel->mControlSize.height < Math::MACHINE_EPSILON_1000)))
     {
       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
     }
 
     // Layout operations that need to be done if the size changes.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                             LAYOUT                    |
-                                                             ALIGN                     |
-                                                             UPDATE_LAYOUT_SIZE        |
-                                                             REORDER );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                            LAYOUT |
+                                                            ALIGN |
+                                                            UPDATE_LAYOUT_SIZE |
+                                                            REORDER);
     // Set the update info to relayout the whole text.
     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
-    mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mCharacterIndex     = 0u;
 
     // Store the size used to layout the text.
     mImpl->mModel->mVisualModel->mControlSize = size;
   }
 
   // Whether there are modify events.
-  if( 0u != mImpl->mModifyEvents.Count() )
+  if(0u != mImpl->mModifyEvents.Count())
   {
     // Style operations that need to be done if the text is modified.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                             COLOR );
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                            COLOR);
   }
 
   // Set the update info to elide the text.
-  if( mImpl->mModel->mElideEnabled ||
-      ( ( NULL != mImpl->mEventData ) && mImpl->mEventData->mIsPlaceholderElideEnabled ) )
+  if(mImpl->mModel->mElideEnabled ||
+     ((NULL != mImpl->mEventData) && mImpl->mEventData->mIsPlaceholderElideEnabled))
   {
     // Update Text layout for applying elided
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                             ALIGN                     |
-                                                             LAYOUT                    |
-                                                             UPDATE_LAYOUT_SIZE        |
-                                                             REORDER );
+    mImpl->mOperationsPending                  = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                            ALIGN |
+                                                            LAYOUT |
+                                                            UPDATE_LAYOUT_SIZE |
+                                                            REORDER);
     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
-    mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mCharacterIndex     = 0u;
   }
 
-  if( mImpl->mModel->mMatchSystemLanguageDirection  && mImpl->mLayoutDirection != layoutDirection )
+  if(mImpl->mModel->mMatchSystemLanguageDirection && mImpl->mLayoutDirection != layoutDirection)
   {
     // Clear the update info. This info will be set the next time the text is updated.
     mImpl->mTextUpdateInfo.mClearAll = true;
     // Apply modifications to the model
     // Shape the text again is needed because characters like '()[]{}' have to be mirrored and the glyphs generated again.
-    mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                             GET_GLYPH_METRICS         |
-                                                             SHAPE_TEXT                |
-                                                             UPDATE_DIRECTION          |
-                                                             LAYOUT                    |
-                                                             BIDI_INFO                 |
-                                                             REORDER );
-    mImpl->mLayoutDirection = layoutDirection;
+    mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                            GET_GLYPH_METRICS |
+                                                            SHAPE_TEXT |
+                                                            UPDATE_DIRECTION |
+                                                            LAYOUT |
+                                                            BIDI_INFO |
+                                                            REORDER);
+    mImpl->mLayoutDirection   = layoutDirection;
   }
 
   // Make sure the model is up-to-date before layouting.
   ProcessModifyEvents();
-  bool updated = mImpl->UpdateModel( mImpl->mOperationsPending );
+  bool updated = mImpl->UpdateModel(mImpl->mOperationsPending);
 
   // Layout the text.
   Size layoutSize;
-  updated = DoRelayout( size,
-                        mImpl->mOperationsPending,
-                        layoutSize ) || updated;
-
+  updated = DoRelayout(size,
+                       mImpl->mOperationsPending,
+                       layoutSize) ||
+            updated;
 
-  if( updated )
+  if(updated)
   {
     updateTextType = MODEL_UPDATED;
   }
 
   // Do not re-do any operation until something changes.
-  mImpl->mOperationsPending = NO_OPERATION;
+  mImpl->mOperationsPending          = NO_OPERATION;
   mImpl->mModel->mScrollPositionLast = mImpl->mModel->mScrollPosition;
 
   // Whether the text control is editable
@@ -2052,38 +2044,38 @@ Controller::UpdateTextType Controller::Relayout( const Size& size, Dali::LayoutD
 
   // Keep the current offset as it will be used to update the decorator's positions (if the size changes).
   Vector2 offset;
-  if( newSize && isEditable )
+  if(newSize && isEditable)
   {
     offset = mImpl->mModel->mScrollPosition;
   }
 
-  if( !isEditable || !IsMultiLineEnabled() )
+  if(!isEditable || !IsMultiLineEnabled())
   {
     // After doing the text layout, the vertical offset to place the actor in the desired position can be calculated.
-    CalculateVerticalOffset( size );
+    CalculateVerticalOffset(size);
   }
 
-  if( isEditable )
+  if(isEditable)
   {
-    if( newSize )
+    if(newSize)
     {
       // If there is a new size, the scroll position needs to be clamped.
-      mImpl->ClampHorizontalScroll( layoutSize );
+      mImpl->ClampHorizontalScroll(layoutSize);
 
       // Update the decorator's positions is needed if there is a new size.
-      mImpl->mEventData->mDecorator->UpdatePositions( mImpl->mModel->mScrollPosition - offset );
+      mImpl->mEventData->mDecorator->UpdatePositions(mImpl->mModel->mScrollPosition - offset);
     }
 
     // Move the cursor, grab handle etc.
-    if( mImpl->ProcessInputEvents() )
+    if(mImpl->ProcessInputEvents())
     {
-      updateTextType = static_cast<UpdateTextType>( updateTextType | DECORATOR_UPDATED );
+      updateTextType = static_cast<UpdateTextType>(updateTextType | DECORATOR_UPDATED);
     }
   }
 
   // Clear the update info. This info will be set the next time the text is updated.
   mImpl->mTextUpdateInfo.Clear();
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::Relayout\n");
 
   return updateTextType;
 }
@@ -2097,28 +2089,28 @@ void Controller::RequestRelayout()
 
 bool Controller::IsInputStyleChangedSignalsQueueEmpty()
 {
-  return ( NULL == mImpl->mEventData ) || ( 0u == mImpl->mEventData->mInputStyleChangedQueue.Count() );
+  return (NULL == mImpl->mEventData) || (0u == mImpl->mEventData->mInputStyleChangedQueue.Count());
 }
 
 void Controller::ProcessInputStyleChangedSignals()
 {
-  if( NULL == mImpl->mEventData )
+  if(NULL == mImpl->mEventData)
   {
     // Nothing to do.
     return;
   }
 
-  for( Vector<InputStyle::Mask>::ConstIterator it = mImpl->mEventData->mInputStyleChangedQueue.Begin(),
-         endIt = mImpl->mEventData->mInputStyleChangedQueue.End();
-       it != endIt;
-       ++it )
+  for(Vector<InputStyle::Mask>::ConstIterator it    = mImpl->mEventData->mInputStyleChangedQueue.Begin(),
+                                              endIt = mImpl->mEventData->mInputStyleChangedQueue.End();
+      it != endIt;
+      ++it)
   {
     const InputStyle::Mask mask = *it;
 
-    if( NULL != mImpl->mEditableControlInterface )
+    if(NULL != mImpl->mEditableControlInterface)
     {
       // Emit the input style changed signal.
-      mImpl->mEditableControlInterface->InputStyleChanged( mask );
+      mImpl->mEditableControlInterface->InputStyleChanged(mask);
     }
   }
 
@@ -2137,37 +2129,37 @@ void Controller::KeyboardFocusLostEvent()
   EventHandler::KeyboardFocusLostEvent(*this);
 }
 
-bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
+bool Controller::KeyEvent(const Dali::KeyEvent& keyEvent)
 {
   return EventHandler::KeyEvent(*this, keyEvent);
 }
 
-void Controller::TapEvent( unsigned int tapCount, float x, float y )
+void Controller::TapEvent(unsigned int tapCount, float x, float y)
 {
   EventHandler::TapEvent(*this, tapCount, x, y);
 }
 
-void Controller::PanEvent( GestureState state, const Vector2& displacement )
+void Controller::PanEvent(GestureState state, const Vector2& displacement)
 {
   EventHandler::PanEvent(*this, state, displacement);
 }
 
-void Controller::LongPressEvent( GestureState state, float x, float y )
+void Controller::LongPressEvent(GestureState state, float x, float y)
 {
   EventHandler::LongPressEvent(*this, state, x, y);
 }
 
-void Controller::SelectEvent( float x, float y, SelectionType selectType )
+void Controller::SelectEvent(float x, float y, SelectionType selectType)
 {
   EventHandler::SelectEvent(*this, x, y, selectType);
 }
 
-void Controller::SetTextSelectionRange(const uint32_t *start, const uint32_t *end)
+void Controller::SetTextSelectionRange(const uint32_t* start, const uint32_t* end)
 {
-  if( mImpl->mEventData )
+  if(mImpl->mEventData)
   {
-    mImpl->mEventData->mCheckScrollAmount = true;
-    mImpl->mEventData->mIsLeftHandleSelected = true;
+    mImpl->mEventData->mCheckScrollAmount     = true;
+    mImpl->mEventData->mIsLeftHandleSelected  = true;
     mImpl->mEventData->mIsRightHandleSelected = true;
     mImpl->SetTextSelectionRange(start, end);
     mImpl->RequestRelayout();
@@ -2182,25 +2174,25 @@ Uint32Pair Controller::GetTextSelectionRange() const
 
 void Controller::SelectWholeText()
 {
-  SelectEvent( 0.f, 0.f, SelectionType::ALL );
+  SelectEvent(0.f, 0.f, SelectionType::ALL);
 }
 
 void Controller::SelectNone()
 {
-  SelectEvent( 0.f, 0.f, SelectionType::NONE );
+  SelectEvent(0.f, 0.f, SelectionType::NONE);
 }
 
 string Controller::GetSelectedText() const
 {
   string text;
-  if( EventData::SELECTING == mImpl->mEventData->mState )
+  if(EventData::SELECTING == mImpl->mEventData->mState)
   {
-    mImpl->RetrieveSelection( text, false );
+    mImpl->RetrieveSelection(text, false);
   }
   return text;
 }
 
-InputMethodContext::CallbackData Controller::OnInputMethodContextEvent( InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent )
+InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
 {
   return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
 }
@@ -2212,16 +2204,16 @@ void Controller::PasteClipboardItemEvent()
 
 // protected : Inherit from Text::Decorator::ControllerInterface.
 
-void Controller::GetTargetSize( Vector2& targetSize )
+void Controller::GetTargetSize(Vector2& targetSize)
 {
   targetSize = mImpl->mModel->mVisualModel->mControlSize;
 }
 
-void Controller::AddDecoration( Actor& actor, bool needsClipping )
+void Controller::AddDecoration(Actor& actor, bool needsClipping)
 {
-  if( NULL != mImpl->mEditableControlInterface )
+  if(NULL != mImpl->mEditableControlInterface)
   {
-    mImpl->mEditableControlInterface->AddDecoration( actor, needsClipping );
+    mImpl->mEditableControlInterface->AddDecoration(actor, needsClipping);
   }
 }
 
@@ -2230,23 +2222,23 @@ bool Controller::IsEditable() const
   return mImpl->IsEditable();
 }
 
-void Controller::SetEditable( bool editable )
+void Controller::SetEditable(bool editable)
 {
-  mImpl->SetEditable( editable );
+  mImpl->SetEditable(editable);
   if(mImpl->mEventData && mImpl->mEventData->mDecorator)
   {
-    mImpl->mEventData->mDecorator->SetEditable( editable );
+    mImpl->mEventData->mDecorator->SetEditable(editable);
   }
 }
 
-void Controller::DecorationEvent( HandleType handleType, HandleState state, float x, float y )
+void Controller::DecorationEvent(HandleType handleType, HandleState state, float x, float y)
 {
   EventHandler::DecorationEvent(*this, handleType, state, x, y);
 }
 
 // protected : Inherit from TextSelectionPopup::TextPopupButtonCallbackInterface.
 
-void Controller::TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::Buttons button )
+void Controller::TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::Buttons button)
 {
   EventHandler::TextPopupButtonTouched(*this, button);
 }
@@ -2262,100 +2254,97 @@ void Controller::DisplayTimeExpired()
 
 // private : Update.
 
-void Controller::InsertText( const std::string& text, Controller::InsertType type )
+void Controller::InsertText(const std::string& text, Controller::InsertType type)
 {
-  bool removedPrevious = false;
-  bool removedSelected = false;
+  bool removedPrevious  = false;
+  bool removedSelected  = false;
   bool maxLengthReached = false;
 
-  DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected InsertText" )
+  DALI_ASSERT_DEBUG(NULL != mImpl->mEventData && "Unexpected InsertText")
 
-  if( NULL == mImpl->mEventData )
+  if(NULL == mImpl->mEventData)
   {
     return;
   }
 
-  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 );
+  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);
 
   // TODO: At the moment the underline runs are only for pre-edit.
   mImpl->mModel->mVisualModel->mUnderlineRuns.Clear();
 
   // Remove the previous InputMethodContext pre-edit.
-  if( mImpl->mEventData->mPreEditFlag && ( 0u != mImpl->mEventData->mPreEditLength ) )
+  if(mImpl->mEventData->mPreEditFlag && (0u != mImpl->mEventData->mPreEditLength))
   {
-    removedPrevious = RemoveText( -static_cast<int>( mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition ),
-                                  mImpl->mEventData->mPreEditLength,
-                                  DONT_UPDATE_INPUT_STYLE );
+    removedPrevious = RemoveText(-static_cast<int>(mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition),
+                                 mImpl->mEventData->mPreEditLength,
+                                 DONT_UPDATE_INPUT_STYLE);
 
     mImpl->mEventData->mPrimaryCursorPosition = mImpl->mEventData->mPreEditStartPosition;
-    mImpl->mEventData->mPreEditLength = 0u;
+    mImpl->mEventData->mPreEditLength         = 0u;
   }
   else
   {
     // Remove the previous Selection.
     removedSelected = RemoveSelectedText();
-
   }
 
   Vector<Character> utf32Characters;
-  Length characterCount = 0u;
+  Length            characterCount = 0u;
 
-  if( !text.empty() )
+  if(!text.empty())
   {
     //  Convert text into UTF-32
-    utf32Characters.Resize( text.size() );
+    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() );
+    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 );
+    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() );
+    DALI_ASSERT_DEBUG(text.size() >= utf32Characters.Count() && "Invalid UTF32 conversion length");
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "UTF8 size %d, UTF32 size %d\n", text.size(), utf32Characters.Count());
   }
 
-  if( 0u != utf32Characters.Count() ) // Check if Utf8ToUtf32 conversion succeeded
+  if(0u != utf32Characters.Count()) // Check if Utf8ToUtf32 conversion succeeded
   {
     // The placeholder text is no longer needed
-    if( mImpl->IsShowingPlaceholderText() )
+    if(mImpl->IsShowingPlaceholderText())
     {
       ResetText();
     }
 
-    mImpl->ChangeState( EventData::EDITING );
+    mImpl->ChangeState(EventData::EDITING);
 
     // Handle the InputMethodContext (predicitive text) state changes
-    if( COMMIT == type )
+    if(COMMIT == type)
     {
       // InputMethodContext is no longer handling key-events
       mImpl->ClearPreEditFlag();
     }
     else // PRE_EDIT
     {
-      if( !mImpl->mEventData->mPreEditFlag )
+      if(!mImpl->mEventData->mPreEditFlag)
       {
-        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Entered PreEdit state\n" );
+        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Entered PreEdit state\n");
 
         // Record the start of the pre-edit text
         mImpl->mEventData->mPreEditStartPosition = mImpl->mEventData->mPrimaryCursorPosition;
       }
 
       mImpl->mEventData->mPreEditLength = utf32Characters.Count();
-      mImpl->mEventData->mPreEditFlag = true;
+      mImpl->mEventData->mPreEditFlag   = true;
 
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "mPreEditStartPosition %d mPreEditLength %d\n", mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
+      DALI_LOG_INFO(gLogFilter, Debug::Verbose, "mPreEditStartPosition %d mPreEditLength %d\n", mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength);
     }
 
     const Length numberOfCharactersInModel = mImpl->mModel->mLogicalModel->mText.Count();
 
     // Restrict new text to fit within Maximum characters setting.
-    Length maxSizeOfNewText = std::min( ( mImpl->mMaximumNumberOfCharacters - numberOfCharactersInModel ), characterCount );
-    maxLengthReached = ( characterCount > maxSizeOfNewText );
+    Length maxSizeOfNewText = std::min((mImpl->mMaximumNumberOfCharacters - numberOfCharactersInModel), characterCount);
+    maxLengthReached        = (characterCount > maxSizeOfNewText);
 
     // The cursor position.
     CharacterIndex& cursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
@@ -2363,136 +2352,136 @@ void Controller::InsertText( const std::string& text, Controller::InsertType typ
     // Update the text's style.
 
     // Updates the text style runs by adding characters.
-    mImpl->mModel->mLogicalModel->UpdateTextStyleRuns( cursorIndex, maxSizeOfNewText );
+    mImpl->mModel->mLogicalModel->UpdateTextStyleRuns(cursorIndex, maxSizeOfNewText);
 
     // Get the character index from the cursor index.
-    const CharacterIndex styleIndex = ( cursorIndex > 0u ) ? cursorIndex - 1u : 0u;
+    const CharacterIndex styleIndex = (cursorIndex > 0u) ? cursorIndex - 1u : 0u;
 
     // Retrieve the text's style for the given index.
     InputStyle style;
-    mImpl->RetrieveDefaultInputStyle( style );
-    mImpl->mModel->mLogicalModel->RetrieveStyle( styleIndex, style );
+    mImpl->RetrieveDefaultInputStyle(style);
+    mImpl->mModel->mLogicalModel->RetrieveStyle(styleIndex, style);
 
     // Whether to add a new text color run.
-    const bool addColorRun = ( style.textColor != mImpl->mEventData->mInputStyle.textColor ) && !mImpl->mEventData->mInputStyle.isDefaultColor;
+    const bool addColorRun = (style.textColor != mImpl->mEventData->mInputStyle.textColor) && !mImpl->mEventData->mInputStyle.isDefaultColor;
 
     // Whether to add a new font run.
-    const bool addFontNameRun = ( style.familyName != mImpl->mEventData->mInputStyle.familyName ) && mImpl->mEventData->mInputStyle.isFamilyDefined;
-    const bool addFontWeightRun = ( style.weight != mImpl->mEventData->mInputStyle.weight ) && mImpl->mEventData->mInputStyle.isWeightDefined;
-    const bool addFontWidthRun = ( style.width != mImpl->mEventData->mInputStyle.width ) && mImpl->mEventData->mInputStyle.isWidthDefined;
-    const bool addFontSlantRun = ( style.slant != mImpl->mEventData->mInputStyle.slant ) && mImpl->mEventData->mInputStyle.isSlantDefined;
-    const bool addFontSizeRun = ( style.size != mImpl->mEventData->mInputStyle.size ) && mImpl->mEventData->mInputStyle.isSizeDefined ;
+    const bool addFontNameRun   = (style.familyName != mImpl->mEventData->mInputStyle.familyName) && mImpl->mEventData->mInputStyle.isFamilyDefined;
+    const bool addFontWeightRun = (style.weight != mImpl->mEventData->mInputStyle.weight) && mImpl->mEventData->mInputStyle.isWeightDefined;
+    const bool addFontWidthRun  = (style.width != mImpl->mEventData->mInputStyle.width) && mImpl->mEventData->mInputStyle.isWidthDefined;
+    const bool addFontSlantRun  = (style.slant != mImpl->mEventData->mInputStyle.slant) && mImpl->mEventData->mInputStyle.isSlantDefined;
+    const bool addFontSizeRun   = (style.size != mImpl->mEventData->mInputStyle.size) && mImpl->mEventData->mInputStyle.isSizeDefined;
 
     // Add style runs.
-    if( addColorRun )
+    if(addColorRun)
     {
       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mColorRuns.Count();
-      mImpl->mModel->mLogicalModel->mColorRuns.Resize( numberOfRuns + 1u );
+      mImpl->mModel->mLogicalModel->mColorRuns.Resize(numberOfRuns + 1u);
 
-      ColorRun& colorRun = *( mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns );
-      colorRun.color = mImpl->mEventData->mInputStyle.textColor;
-      colorRun.characterRun.characterIndex = cursorIndex;
+      ColorRun& colorRun                       = *(mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns);
+      colorRun.color                           = mImpl->mEventData->mInputStyle.textColor;
+      colorRun.characterRun.characterIndex     = cursorIndex;
       colorRun.characterRun.numberOfCharacters = maxSizeOfNewText;
     }
 
-    if( addFontNameRun   ||
-        addFontWeightRun ||
-        addFontWidthRun  ||
-        addFontSlantRun  ||
-        addFontSizeRun )
+    if(addFontNameRun ||
+       addFontWeightRun ||
+       addFontWidthRun ||
+       addFontSlantRun ||
+       addFontSizeRun)
     {
       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Count();
-      mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Resize( numberOfRuns + 1u );
+      mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Resize(numberOfRuns + 1u);
 
-      FontDescriptionRun& fontDescriptionRun = *( mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Begin() + numberOfRuns );
+      FontDescriptionRun& fontDescriptionRun = *(mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Begin() + numberOfRuns);
 
-      if( addFontNameRun )
+      if(addFontNameRun)
       {
         fontDescriptionRun.familyLength = mImpl->mEventData->mInputStyle.familyName.size();
-        fontDescriptionRun.familyName = new char[fontDescriptionRun.familyLength];
-        memcpy( fontDescriptionRun.familyName, mImpl->mEventData->mInputStyle.familyName.c_str(), fontDescriptionRun.familyLength );
+        fontDescriptionRun.familyName   = new char[fontDescriptionRun.familyLength];
+        memcpy(fontDescriptionRun.familyName, mImpl->mEventData->mInputStyle.familyName.c_str(), fontDescriptionRun.familyLength);
         fontDescriptionRun.familyDefined = true;
 
         // The memory allocated for the font family name is freed when the font description is removed from the logical model.
       }
 
-      if( addFontWeightRun )
+      if(addFontWeightRun)
       {
-        fontDescriptionRun.weight = mImpl->mEventData->mInputStyle.weight;
+        fontDescriptionRun.weight        = mImpl->mEventData->mInputStyle.weight;
         fontDescriptionRun.weightDefined = true;
       }
 
-      if( addFontWidthRun )
+      if(addFontWidthRun)
       {
-        fontDescriptionRun.width = mImpl->mEventData->mInputStyle.width;
+        fontDescriptionRun.width        = mImpl->mEventData->mInputStyle.width;
         fontDescriptionRun.widthDefined = true;
       }
 
-      if( addFontSlantRun )
+      if(addFontSlantRun)
       {
-        fontDescriptionRun.slant = mImpl->mEventData->mInputStyle.slant;
+        fontDescriptionRun.slant        = mImpl->mEventData->mInputStyle.slant;
         fontDescriptionRun.slantDefined = true;
       }
 
-      if( addFontSizeRun )
+      if(addFontSizeRun)
       {
-        fontDescriptionRun.size = static_cast<PointSize26Dot6>( mImpl->mEventData->mInputStyle.size * 64.f );
+        fontDescriptionRun.size        = static_cast<PointSize26Dot6>(mImpl->mEventData->mInputStyle.size * 64.f);
         fontDescriptionRun.sizeDefined = true;
       }
 
-      fontDescriptionRun.characterRun.characterIndex = cursorIndex;
+      fontDescriptionRun.characterRun.characterIndex     = cursorIndex;
       fontDescriptionRun.characterRun.numberOfCharacters = maxSizeOfNewText;
     }
 
     // Insert at current cursor position.
     Vector<Character>& modifyText = mImpl->mModel->mLogicalModel->mText;
 
-    if( cursorIndex < numberOfCharactersInModel )
+    if(cursorIndex < numberOfCharactersInModel)
     {
-      modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
+      modifyText.Insert(modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText);
     }
     else
     {
-      modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
+      modifyText.Insert(modifyText.End(), utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText);
     }
 
     // Mark the first paragraph to be updated.
-    if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() )
+    if(Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout())
     {
-      mImpl->mTextUpdateInfo.mCharacterIndex = 0;
+      mImpl->mTextUpdateInfo.mCharacterIndex             = 0;
       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-      mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = numberOfCharactersInModel + maxSizeOfNewText;
-      mImpl->mTextUpdateInfo.mClearAll = true;
+      mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = numberOfCharactersInModel + maxSizeOfNewText;
+      mImpl->mTextUpdateInfo.mClearAll                   = true;
     }
     else
     {
-      mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex );
+      mImpl->mTextUpdateInfo.mCharacterIndex = std::min(cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex);
       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd += maxSizeOfNewText;
     }
 
     // Update the cursor index.
     cursorIndex += maxSizeOfNewText;
 
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Inserted %d characters, new size %d new cursor %d\n", maxSizeOfNewText, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Inserted %d characters, new size %d new cursor %d\n", maxSizeOfNewText, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition);
   }
 
-  if( ( 0u == mImpl->mModel->mLogicalModel->mText.Count() ) &&
-      mImpl->IsPlaceholderAvailable() )
+  if((0u == mImpl->mModel->mLogicalModel->mText.Count()) &&
+     mImpl->IsPlaceholderAvailable())
   {
     // Show place-holder if empty after removing the pre-edit text
     ShowPlaceholderText();
     mImpl->mEventData->mUpdateCursorPosition = true;
     mImpl->ClearPreEditFlag();
   }
-  else if( removedPrevious ||
-           removedSelected ||
-           ( 0 != utf32Characters.Count() ) )
+  else if(removedPrevious ||
+          removedSelected ||
+          (0 != utf32Characters.Count()))
   {
     // Queue an inserted event
-    mImpl->QueueModifyEvent( ModifyEvent::TEXT_INSERTED );
+    mImpl->QueueModifyEvent(ModifyEvent::TEXT_INSERTED);
 
     mImpl->mEventData->mUpdateCursorPosition = true;
-    if( removedSelected )
+    if(removedSelected)
     {
       mImpl->mEventData->mScrollAfterDelete = true;
     }
@@ -2502,13 +2491,13 @@ void Controller::InsertText( const std::string& text, Controller::InsertType typ
     }
   }
 
-  if( maxLengthReached )
+  if(maxLengthReached)
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mModel->mLogicalModel->mText.Count() );
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mModel->mLogicalModel->mText.Count());
 
     mImpl->ResetInputMethodContext();
 
-    if( NULL != mImpl->mEditableControlInterface )
+    if(NULL != mImpl->mEditableControlInterface)
     {
       // Do this last since it provides callbacks into application code
       mImpl->mEditableControlInterface->MaxLengthReached();
@@ -2516,122 +2505,121 @@ void Controller::InsertText( const std::string& text, Controller::InsertType typ
   }
 }
 
-void Controller::PasteText( const std::string& stringToPaste )
+void Controller::PasteText(const std::string& stringToPaste)
 {
-  InsertText( stringToPaste, Text::Controller::COMMIT );
-  mImpl->ChangeState( EventData::EDITING );
+  InsertText(stringToPaste, Text::Controller::COMMIT);
+  mImpl->ChangeState(EventData::EDITING);
   mImpl->RequestRelayout();
 
-  if( NULL != mImpl->mEditableControlInterface )
+  if(NULL != mImpl->mEditableControlInterface)
   {
     // Do this last since it provides callbacks into application code
-    mImpl->mEditableControlInterface->TextChanged();
+    mImpl->mEditableControlInterface->TextChanged(true);
   }
 }
 
-bool Controller::RemoveText( int cursorOffset,
-                             int numberOfCharacters,
-                             UpdateInputStyleType type )
+bool Controller::RemoveText(int                  cursorOffset,
+                            int                  numberOfCharacters,
+                            UpdateInputStyleType type)
 {
   bool removed = false;
 
-  if( NULL == mImpl->mEventData )
+  if(NULL == mImpl->mEventData)
   {
     return removed;
   }
 
-  DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p mText.Count() %d cursor %d cursorOffset %d numberOfCharacters %d\n",
-                 this, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition, cursorOffset, numberOfCharacters );
+  DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::RemoveText %p mText.Count() %d cursor %d cursorOffset %d numberOfCharacters %d\n", this, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition, cursorOffset, numberOfCharacters);
 
-  if( !mImpl->IsShowingPlaceholderText() )
+  if(!mImpl->IsShowingPlaceholderText())
   {
     // Delete at current cursor position
-    Vector<Character>& currentText = mImpl->mModel->mLogicalModel->mText;
-    CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
+    Vector<Character>& currentText    = mImpl->mModel->mLogicalModel->mText;
+    CharacterIndex&    oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
 
     CharacterIndex cursorIndex = 0;
 
     // Validate the cursor position & number of characters
-    if( ( static_cast< int >( mImpl->mEventData->mPrimaryCursorPosition ) + cursorOffset ) >= 0 )
+    if((static_cast<int>(mImpl->mEventData->mPrimaryCursorPosition) + cursorOffset) >= 0)
     {
       cursorIndex = mImpl->mEventData->mPrimaryCursorPosition + cursorOffset;
     }
 
-    if( ( cursorIndex + numberOfCharacters ) > currentText.Count() )
+    if((cursorIndex + numberOfCharacters) > currentText.Count())
     {
       numberOfCharacters = currentText.Count() - cursorIndex;
     }
 
-    if( mImpl->mEventData->mPreEditFlag || // If the preedit flag is enabled, it means two (or more) of them came together i.e. when two keys have been pressed at the same time.
-        ( ( cursorIndex + numberOfCharacters ) <= mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters ) )
+    if(mImpl->mEventData->mPreEditFlag || // If the preedit flag is enabled, it means two (or more) of them came together i.e. when two keys have been pressed at the same time.
+       ((cursorIndex + numberOfCharacters) <= mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters))
     {
       // Mark the paragraphs to be updated.
-      if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() )
+      if(Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout())
       {
-        mImpl->mTextUpdateInfo.mCharacterIndex = 0;
+        mImpl->mTextUpdateInfo.mCharacterIndex             = 0;
         mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-        mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters - numberOfCharacters;
-        mImpl->mTextUpdateInfo.mClearAll = true;
+        mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters - numberOfCharacters;
+        mImpl->mTextUpdateInfo.mClearAll                   = true;
       }
       else
       {
-        mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex );
+        mImpl->mTextUpdateInfo.mCharacterIndex = std::min(cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex);
         mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove += numberOfCharacters;
       }
 
       // Update the input style and remove the text's style before removing the text.
 
-      if( UPDATE_INPUT_STYLE == type )
+      if(UPDATE_INPUT_STYLE == type)
       {
         // Keep a copy of the current input style.
         InputStyle currentInputStyle;
-        currentInputStyle.Copy( mImpl->mEventData->mInputStyle );
+        currentInputStyle.Copy(mImpl->mEventData->mInputStyle);
 
         // Set first the default input style.
-        mImpl->RetrieveDefaultInputStyle( mImpl->mEventData->mInputStyle );
+        mImpl->RetrieveDefaultInputStyle(mImpl->mEventData->mInputStyle);
 
         // Update the input style.
-        mImpl->mModel->mLogicalModel->RetrieveStyle( cursorIndex, mImpl->mEventData->mInputStyle );
+        mImpl->mModel->mLogicalModel->RetrieveStyle(cursorIndex, mImpl->mEventData->mInputStyle);
 
         // Compare if the input style has changed.
-        const bool hasInputStyleChanged = !currentInputStyle.Equal( mImpl->mEventData->mInputStyle );
+        const bool hasInputStyleChanged = !currentInputStyle.Equal(mImpl->mEventData->mInputStyle);
 
-        if( hasInputStyleChanged )
+        if(hasInputStyleChanged)
         {
-          const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask( mImpl->mEventData->mInputStyle );
+          const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask(mImpl->mEventData->mInputStyle);
           // Queue the input style changed signal.
-          mImpl->mEventData->mInputStyleChangedQueue.PushBack( styleChangedMask );
+          mImpl->mEventData->mInputStyleChangedQueue.PushBack(styleChangedMask);
         }
       }
 
       // If the number of current text and the number of characters to be deleted are same,
       // it means all texts should be removed and all Preedit variables should be initialized.
-      if( ( currentText.Count() - numberOfCharacters == 0 ) && ( cursorIndex == 0 ) )
+      if((currentText.Count() - numberOfCharacters == 0) && (cursorIndex == 0))
       {
         mImpl->ClearPreEditFlag();
         mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = 0;
       }
 
       // Updates the text style runs by removing characters. Runs with no characters are removed.
-      mImpl->mModel->mLogicalModel->UpdateTextStyleRuns( cursorIndex, -numberOfCharacters );
+      mImpl->mModel->mLogicalModel->UpdateTextStyleRuns(cursorIndex, -numberOfCharacters);
 
       // Remove the characters.
       Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
       Vector<Character>::Iterator last  = first + numberOfCharacters;
 
-      currentText.Erase( first, last );
+      currentText.Erase(first, last);
 
       // Cursor position retreat
       oldCursorIndex = cursorIndex;
 
       mImpl->mEventData->mScrollAfterDelete = true;
 
-      if( EventData::INACTIVE == mImpl->mEventData->mState )
+      if(EventData::INACTIVE == mImpl->mEventData->mState)
       {
-        mImpl->ChangeState( EventData::EDITING );
+        mImpl->ChangeState(EventData::EDITING);
       }
 
-      DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfCharacters );
+      DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfCharacters);
       removed = true;
     }
   }
@@ -2641,17 +2629,17 @@ bool Controller::RemoveText( int cursorOffset,
 
 bool Controller::RemoveSelectedText()
 {
-  bool textRemoved( false );
+  bool textRemoved(false);
 
-  if( EventData::SELECTING == mImpl->mEventData->mState )
+  if(EventData::SELECTING == mImpl->mEventData->mState)
   {
     std::string removedString;
-    mImpl->RetrieveSelection( removedString, true );
+    mImpl->RetrieveSelection(removedString, true);
 
-    if( !removedString.empty() )
+    if(!removedString.empty())
     {
       textRemoved = true;
-      mImpl->ChangeState( EventData::EDITING );
+      mImpl->ChangeState(EventData::EDITING);
     }
   }
 
@@ -2660,105 +2648,105 @@ bool Controller::RemoveSelectedText()
 
 // private : Relayout.
 
-bool Controller::DoRelayout( const Size& size,
-                             OperationsMask operationsRequired,
-                             Size& layoutSize )
+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 );
+  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.
-  const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
+  const OperationsMask operations = static_cast<OperationsMask>(mImpl->mOperationsPending & operationsRequired);
 
-  const CharacterIndex startIndex = mImpl->mTextUpdateInfo.mParagraphCharacterIndex;
-  const Length requestedNumberOfCharacters = mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters;
+  const CharacterIndex startIndex                  = mImpl->mTextUpdateInfo.mParagraphCharacterIndex;
+  const Length         requestedNumberOfCharacters = mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters;
 
   // Get the current layout size.
   layoutSize = mImpl->mModel->mVisualModel->GetLayoutSize();
 
-  if( NO_OPERATION != ( LAYOUT & operations ) )
+  if(NO_OPERATION != (LAYOUT & operations))
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::DoRelayout LAYOUT & operations\n");
+    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::DoRelayout LAYOUT & operations\n");
 
     // 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.
 
     // Calculate the number of glyphs to layout.
-    const Vector<GlyphIndex>& charactersToGlyph = mImpl->mModel->mVisualModel->mCharactersToGlyph;
-    const Vector<Length>& glyphsPerCharacter = mImpl->mModel->mVisualModel->mGlyphsPerCharacter;
-    const GlyphIndex* const charactersToGlyphBuffer = charactersToGlyph.Begin();
-    const Length* const glyphsPerCharacterBuffer = glyphsPerCharacter.Begin();
+    const Vector<GlyphIndex>& charactersToGlyph        = mImpl->mModel->mVisualModel->mCharactersToGlyph;
+    const Vector<Length>&     glyphsPerCharacter       = mImpl->mModel->mVisualModel->mGlyphsPerCharacter;
+    const GlyphIndex* const   charactersToGlyphBuffer  = charactersToGlyph.Begin();
+    const Length* const       glyphsPerCharacterBuffer = glyphsPerCharacter.Begin();
 
-    const CharacterIndex lastIndex = startIndex + ( ( requestedNumberOfCharacters > 0u ) ? requestedNumberOfCharacters - 1u : 0u );
-    const GlyphIndex startGlyphIndex = mImpl->mTextUpdateInfo.mStartGlyphIndex;
+    const CharacterIndex lastIndex       = startIndex + ((requestedNumberOfCharacters > 0u) ? requestedNumberOfCharacters - 1u : 0u);
+    const GlyphIndex     startGlyphIndex = mImpl->mTextUpdateInfo.mStartGlyphIndex;
 
     // Make sure the index is not out of bound
-    if ( charactersToGlyph.Count() != glyphsPerCharacter.Count() ||
-         requestedNumberOfCharacters > charactersToGlyph.Count() ||
-         ( lastIndex > charactersToGlyph.Count() && charactersToGlyph.Count() > 0u ) )
+    if(charactersToGlyph.Count() != glyphsPerCharacter.Count() ||
+       requestedNumberOfCharacters > charactersToGlyph.Count() ||
+       (lastIndex > charactersToGlyph.Count() && charactersToGlyph.Count() > 0u))
     {
       std::string currentText;
-      GetText( currentText );
+      GetText(currentText);
 
-      DALI_LOG_ERROR( "Controller::DoRelayout: Attempting to access invalid buffer\n" );
-      DALI_LOG_ERROR( "Current text is: %s\n", currentText.c_str() );
-      DALI_LOG_ERROR( "startIndex: %u, lastIndex: %u, requestedNumberOfCharacters: %u, charactersToGlyph.Count = %lu, glyphsPerCharacter.Count = %lu\n", startIndex, lastIndex, requestedNumberOfCharacters, charactersToGlyph.Count(), glyphsPerCharacter.Count());
+      DALI_LOG_ERROR("Controller::DoRelayout: Attempting to access invalid buffer\n");
+      DALI_LOG_ERROR("Current text is: %s\n", currentText.c_str());
+      DALI_LOG_ERROR("startIndex: %u, lastIndex: %u, requestedNumberOfCharacters: %u, charactersToGlyph.Count = %lu, glyphsPerCharacter.Count = %lu\n", startIndex, lastIndex, requestedNumberOfCharacters, charactersToGlyph.Count(), glyphsPerCharacter.Count());
 
       return false;
     }
 
-    const Length numberOfGlyphs = ( requestedNumberOfCharacters > 0u ) ? *( charactersToGlyphBuffer + lastIndex ) + *( glyphsPerCharacterBuffer + lastIndex ) - startGlyphIndex : 0u;
+    const Length numberOfGlyphs      = (requestedNumberOfCharacters > 0u) ? *(charactersToGlyphBuffer + lastIndex) + *(glyphsPerCharacterBuffer + lastIndex) - startGlyphIndex : 0u;
     const Length totalNumberOfGlyphs = mImpl->mModel->mVisualModel->mGlyphs.Count();
 
-    if( 0u == totalNumberOfGlyphs )
+    if(0u == totalNumberOfGlyphs)
     {
-      if( NO_OPERATION != ( UPDATE_LAYOUT_SIZE & operations ) )
+      if(NO_OPERATION != (UPDATE_LAYOUT_SIZE & operations))
       {
-        mImpl->mModel->mVisualModel->SetLayoutSize( Size::ZERO );
+        mImpl->mModel->mVisualModel->SetLayoutSize(Size::ZERO);
       }
 
       // Nothing else to do if there is no glyphs.
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout no glyphs, view updated true\n" );
+      DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::DoRelayout no glyphs, view updated true\n");
       return true;
     }
 
     // Set the layout parameters.
-    Layout::Parameters layoutParameters( size,
-                                         mImpl->mModel);
+    Layout::Parameters layoutParameters(size,
+                                        mImpl->mModel);
 
     // Resize the vector of positions to have the same size than the vector of glyphs.
     Vector<Vector2>& glyphPositions = mImpl->mModel->mVisualModel->mGlyphPositions;
-    glyphPositions.Resize( totalNumberOfGlyphs );
+    glyphPositions.Resize(totalNumberOfGlyphs);
 
     // Whether the last character is a new paragraph character.
-    const Character* const textBuffer = mImpl->mModel->mLogicalModel->mText.Begin();
-    mImpl->mTextUpdateInfo.mIsLastCharacterNewParagraph =  TextAbstraction::IsNewParagraph( *( textBuffer + ( mImpl->mModel->mLogicalModel->mText.Count() - 1u ) ) );
-    layoutParameters.isLastNewParagraph = mImpl->mTextUpdateInfo.mIsLastCharacterNewParagraph;
+    const Character* const textBuffer                   = mImpl->mModel->mLogicalModel->mText.Begin();
+    mImpl->mTextUpdateInfo.mIsLastCharacterNewParagraph = TextAbstraction::IsNewParagraph(*(textBuffer + (mImpl->mModel->mLogicalModel->mText.Count() - 1u)));
+    layoutParameters.isLastNewParagraph                 = mImpl->mTextUpdateInfo.mIsLastCharacterNewParagraph;
 
     // The initial glyph and the number of glyphs to layout.
-    layoutParameters.startGlyphIndex = startGlyphIndex;
-    layoutParameters.numberOfGlyphs = numberOfGlyphs;
-    layoutParameters.startLineIndex = mImpl->mTextUpdateInfo.mStartLineIndex;
+    layoutParameters.startGlyphIndex        = startGlyphIndex;
+    layoutParameters.numberOfGlyphs         = numberOfGlyphs;
+    layoutParameters.startLineIndex         = mImpl->mTextUpdateInfo.mStartLineIndex;
     layoutParameters.estimatedNumberOfLines = mImpl->mTextUpdateInfo.mEstimatedNumberOfLines;
 
     // Update the ellipsis
     bool elideTextEnabled = mImpl->mModel->mElideEnabled;
 
-    if( NULL != mImpl->mEventData )
+    if(NULL != mImpl->mEventData)
     {
-      if( mImpl->mEventData->mPlaceholderEllipsisFlag && mImpl->IsShowingPlaceholderText() )
+      if(mImpl->mEventData->mPlaceholderEllipsisFlag && mImpl->IsShowingPlaceholderText())
       {
         elideTextEnabled = mImpl->mEventData->mIsPlaceholderElideEnabled;
       }
-      else if( EventData::INACTIVE != mImpl->mEventData->mState )
+      else if(EventData::INACTIVE != mImpl->mEventData->mState)
       {
         // Disable ellipsis when editing
         elideTextEnabled = false;
       }
 
       // Reset the scroll position in inactive state
-      if( elideTextEnabled && ( mImpl->mEventData->mState == EventData::INACTIVE ) )
+      if(elideTextEnabled && (mImpl->mEventData->mState == EventData::INACTIVE))
       {
         ResetScrollPosition();
       }
@@ -2767,86 +2755,86 @@ bool Controller::DoRelayout( const Size& size,
     // Update the visual model.
     bool isAutoScrollEnabled = mImpl->mIsAutoScrollEnabled;
     Size newLayoutSize;
-    viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
-                                                   newLayoutSize,
-                                                   elideTextEnabled,
-                                                   isAutoScrollEnabled );
+    viewUpdated                 = mImpl->mLayoutEngine.LayoutText(layoutParameters,
+                                                  newLayoutSize,
+                                                  elideTextEnabled,
+                                                  isAutoScrollEnabled);
     mImpl->mIsAutoScrollEnabled = isAutoScrollEnabled;
 
-    viewUpdated = viewUpdated || ( newLayoutSize != layoutSize );
+    viewUpdated = viewUpdated || (newLayoutSize != layoutSize);
 
-    if( viewUpdated )
+    if(viewUpdated)
     {
       layoutSize = newLayoutSize;
 
-      if( NO_OPERATION != ( UPDATE_DIRECTION & operations ) )
+      if(NO_OPERATION != (UPDATE_DIRECTION & operations))
       {
         mImpl->mIsTextDirectionRTL = false;
       }
 
-      if ( ( NO_OPERATION != ( UPDATE_DIRECTION & operations ) ) && !mImpl->mModel->mVisualModel->mLines.Empty() )
+      if((NO_OPERATION != (UPDATE_DIRECTION & operations)) && !mImpl->mModel->mVisualModel->mLines.Empty())
       {
         mImpl->mIsTextDirectionRTL = mImpl->mModel->mVisualModel->mLines[0u].direction;
       }
 
       // Sets the layout size.
-      if( NO_OPERATION != ( UPDATE_LAYOUT_SIZE & operations ) )
+      if(NO_OPERATION != (UPDATE_LAYOUT_SIZE & operations))
       {
-        mImpl->mModel->mVisualModel->SetLayoutSize( layoutSize );
+        mImpl->mModel->mVisualModel->SetLayoutSize(layoutSize);
       }
     } // view updated
   }
 
-  if( NO_OPERATION != ( ALIGN & operations ) )
+  if(NO_OPERATION != (ALIGN & operations))
   {
     // The laid-out lines.
     Vector<LineRun>& lines = mImpl->mModel->mVisualModel->mLines;
 
-    CharacterIndex alignStartIndex = startIndex;
-    Length alignRequestedNumberOfCharacters = requestedNumberOfCharacters;
+    CharacterIndex alignStartIndex                  = startIndex;
+    Length         alignRequestedNumberOfCharacters = requestedNumberOfCharacters;
 
     // the whole text needs to be full aligned.
     // If you do not do a full aligned, only the last line of the multiline input is aligned.
-    if(  mImpl->mEventData && mImpl->mEventData->mUpdateAlignment )
+    if(mImpl->mEventData && mImpl->mEventData->mUpdateAlignment)
     {
-      alignStartIndex = 0u;
-      alignRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
+      alignStartIndex                     = 0u;
+      alignRequestedNumberOfCharacters    = mImpl->mModel->mLogicalModel->mText.Count();
       mImpl->mEventData->mUpdateAlignment = false;
     }
 
     // Need to align with the control's size as the text may contain lines
     // starting either with left to right text or right to left.
-    mImpl->mLayoutEngine.Align( size,
-                                alignStartIndex,
-                                alignRequestedNumberOfCharacters,
-                                mImpl->mModel->mHorizontalAlignment,
-                                lines,
-                                mImpl->mModel->mAlignmentOffset,
-                                mImpl->mLayoutDirection,
-                                mImpl->mModel->mMatchSystemLanguageDirection );
+    mImpl->mLayoutEngine.Align(size,
+                               alignStartIndex,
+                               alignRequestedNumberOfCharacters,
+                               mImpl->mModel->mHorizontalAlignment,
+                               lines,
+                               mImpl->mModel->mAlignmentOffset,
+                               mImpl->mLayoutDirection,
+                               mImpl->mModel->mMatchSystemLanguageDirection);
 
     viewUpdated = true;
   }
 #if defined(DEBUG_ENABLED)
   std::string currentText;
-  GetText( currentText );
-  DALI_LOG_INFO( gLogFilter, Debug::Concise, "Controller::DoRelayout [%p] mImpl->mIsTextDirectionRTL[%s] [%s]\n", this, (mImpl->mIsTextDirectionRTL)?"true":"false",  currentText.c_str() );
+  GetText(currentText);
+  DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::DoRelayout [%p] mImpl->mIsTextDirectionRTL[%s] [%s]\n", this, (mImpl->mIsTextDirectionRTL) ? "true" : "false", currentText.c_str());
 #endif
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", ( viewUpdated ? "true" : "false" ) );
+  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", (viewUpdated ? "true" : "false"));
   return viewUpdated;
 }
 
-void Controller::CalculateVerticalOffset( const Size& controlSize )
+void Controller::CalculateVerticalOffset(const Size& controlSize)
 {
-  ModelPtr&       model         = mImpl->mModel;
-  VisualModelPtr& visualModel   = model->mVisualModel;
-  Size            layoutSize    = mImpl->mModel->mVisualModel->GetLayoutSize();
-  Size            oldLayoutSize = layoutSize;
-  float           offsetY       = 0.f;
-  bool            needRecalc    = false;
+  ModelPtr&       model                 = mImpl->mModel;
+  VisualModelPtr& visualModel           = model->mVisualModel;
+  Size            layoutSize            = mImpl->mModel->mVisualModel->GetLayoutSize();
+  Size            oldLayoutSize         = layoutSize;
+  float           offsetY               = 0.f;
+  bool            needRecalc            = false;
   float           defaultFontLineHeight = mImpl->GetDefaultFontLineHeight();
 
-  if( fabsf( layoutSize.height ) < Math::MACHINE_EPSILON_1000 )
+  if(fabsf(layoutSize.height) < Math::MACHINE_EPSILON_1000)
   {
     // Get the line height of the default font.
     layoutSize.height = defaultFontLineHeight;
@@ -2854,42 +2842,42 @@ void Controller::CalculateVerticalOffset( const Size& controlSize )
 
   // Whether the text control is editable
   const bool isEditable = NULL != mImpl->mEventData;
-  if ( isEditable && layoutSize.height != defaultFontLineHeight )
+  if(isEditable && layoutSize.height != defaultFontLineHeight)
   {
     // This code prevents the wrong positioning of cursor when the layout size is bigger/smaller than defaultFontLineHeight.
     // This situation occurs when the size of placeholder text is different from the default text.
     layoutSize.height = defaultFontLineHeight;
-    needRecalc = true;
+    needRecalc        = true;
   }
 
-  switch( mImpl->mModel->mVerticalAlignment )
+  switch(mImpl->mModel->mVerticalAlignment)
   {
     case VerticalAlignment::TOP:
     {
       mImpl->mModel->mScrollPosition.y = 0.f;
-      offsetY = 0.f;
+      offsetY                          = 0.f;
       break;
     }
     case VerticalAlignment::CENTER:
     {
-      mImpl->mModel->mScrollPosition.y = floorf( 0.5f * ( controlSize.height - layoutSize.height ) ); // try to avoid pixel alignment.
-      if ( needRecalc ) offsetY        = floorf( 0.5f * ( layoutSize.height - oldLayoutSize.height ) );
+      mImpl->mModel->mScrollPosition.y = floorf(0.5f * (controlSize.height - layoutSize.height)); // try to avoid pixel alignment.
+      if(needRecalc) offsetY = floorf(0.5f * (layoutSize.height - oldLayoutSize.height));
       break;
     }
     case VerticalAlignment::BOTTOM:
     {
       mImpl->mModel->mScrollPosition.y = controlSize.height - layoutSize.height;
-      if ( needRecalc ) offsetY        = layoutSize.height - oldLayoutSize.height;
+      if(needRecalc) offsetY = layoutSize.height - oldLayoutSize.height;
       break;
     }
   }
 
-  if ( needRecalc )
+  if(needRecalc)
   {
     // Update glyphPositions according to recalculation.
-    const Length positionCount = visualModel->mGlyphPositions.Count();
+    const Length     positionCount  = visualModel->mGlyphPositions.Count();
     Vector<Vector2>& glyphPositions = visualModel->mGlyphPositions;
-    for( Length index = 0u; index < positionCount; index++ )
+    for(Length index = 0u; index < positionCount; index++)
     {
       glyphPositions[index].y += offsetY;
     }
@@ -2918,7 +2906,7 @@ void Controller::TextDeletedEvent()
   EventHandler::TextDeletedEvent(*this);
 }
 
-bool Controller::DeleteEvent( int keyCode )
+bool Controller::DeleteEvent(int keyCode)
 {
   return EventHandler::DeleteEvent(*this, keyCode);
 }
@@ -2936,9 +2924,9 @@ void Controller::ResetText()
   // We have cleared everything including the placeholder-text
   mImpl->PlaceholderCleared();
 
-  mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+  mImpl->mTextUpdateInfo.mCharacterIndex             = 0u;
   mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-  mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = 0u;
+  mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = 0u;
 
   // Clear any previous text.
   mImpl->mTextUpdateInfo.mClearAll = true;
@@ -2955,11 +2943,11 @@ void Controller::ResetText()
 
 void Controller::ShowPlaceholderText()
 {
-  if( mImpl->IsPlaceholderAvailable() )
+  if(mImpl->IsPlaceholderAvailable())
   {
-    DALI_ASSERT_DEBUG( mImpl->mEventData && "No placeholder text available" );
+    DALI_ASSERT_DEBUG(mImpl->mEventData && "No placeholder text available");
 
-    if( NULL == mImpl->mEventData )
+    if(NULL == mImpl->mEventData)
     {
       return;
     }
@@ -2967,16 +2955,16 @@ void Controller::ShowPlaceholderText()
     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 );
+    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 );
+    const char* text(NULL);
+    size_t      size(0);
 
     // TODO - Switch Placeholder text when changing state
-    if( ( EventData::INACTIVE != mImpl->mEventData->mState ) &&
-        ( 0u != mImpl->mEventData->mPlaceholderTextActive.c_str() ) )
+    if((EventData::INACTIVE != mImpl->mEventData->mState) &&
+       (0u != mImpl->mEventData->mPlaceholderTextActive.c_str()))
     {
       text = mImpl->mEventData->mPlaceholderTextActive.c_str();
       size = mImpl->mEventData->mPlaceholderTextActive.size();
@@ -2987,24 +2975,24 @@ void Controller::ShowPlaceholderText()
       size = mImpl->mEventData->mPlaceholderTextInactive.size();
     }
 
-    mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+    mImpl->mTextUpdateInfo.mCharacterIndex             = 0u;
     mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
 
     // Reset model for showing placeholder.
     mImpl->mModel->mLogicalModel->mText.Clear();
-    mImpl->mModel->mVisualModel->SetTextColor( mImpl->mEventData->mPlaceholderTextColor );
+    mImpl->mModel->mVisualModel->SetTextColor(mImpl->mEventData->mPlaceholderTextColor);
 
     // Convert text into UTF-32
     Vector<Character>& utf32Characters = mImpl->mModel->mLogicalModel->mText;
-    utf32Characters.Resize( size );
+    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 );
+    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.
-    const Length characterCount = Utf8ToUtf32( utf8, size, utf32Characters.Begin() );
-    utf32Characters.Resize( characterCount );
+    const Length characterCount = Utf8ToUtf32(utf8, size, utf32Characters.Begin());
+    utf32Characters.Resize(characterCount);
 
     // The characters to be added.
     mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = characterCount;
@@ -3022,35 +3010,35 @@ void Controller::ShowPlaceholderText()
     mImpl->mOperationsPending = ALL_OPERATIONS;
 
     // Update the rest of the model during size negotiation
-    mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
+    mImpl->QueueModifyEvent(ModifyEvent::TEXT_REPLACED);
   }
 }
 
 void Controller::ClearFontData()
 {
-  if( mImpl->mFontDefaults )
+  if(mImpl->mFontDefaults)
   {
     mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
   }
 
   // Set flags to update the model.
-  mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
+  mImpl->mTextUpdateInfo.mCharacterIndex             = 0u;
   mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
-  mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
+  mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd    = mImpl->mModel->mLogicalModel->mText.Count();
 
-  mImpl->mTextUpdateInfo.mClearAll = true;
+  mImpl->mTextUpdateInfo.mClearAll           = true;
   mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
-  mImpl->mRecalculateNaturalSize = true;
+  mImpl->mRecalculateNaturalSize             = true;
 
-  mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
-                                                           VALIDATE_FONTS            |
-                                                           SHAPE_TEXT                |
-                                                           BIDI_INFO                 |
-                                                           GET_GLYPH_METRICS         |
-                                                           LAYOUT                    |
-                                                           UPDATE_LAYOUT_SIZE        |
-                                                           REORDER                   |
-                                                           ALIGN );
+  mImpl->mOperationsPending = static_cast<OperationsMask>(mImpl->mOperationsPending |
+                                                          VALIDATE_FONTS |
+                                                          SHAPE_TEXT |
+                                                          BIDI_INFO |
+                                                          GET_GLYPH_METRICS |
+                                                          LAYOUT |
+                                                          UPDATE_LAYOUT_SIZE |
+                                                          REORDER |
+                                                          ALIGN);
 }
 
 void Controller::ClearStyleData()
@@ -3059,15 +3047,15 @@ void Controller::ClearStyleData()
   mImpl->mModel->mLogicalModel->ClearFontDescriptionRuns();
 }
 
-void Controller::ResetCursorPosition( CharacterIndex cursorIndex )
+void Controller::ResetCursorPosition(CharacterIndex cursorIndex)
 {
   // Reset the cursor position
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     mImpl->mEventData->mPrimaryCursorPosition = cursorIndex;
 
     // Update the cursor if it's in editing mode.
-    if( EventData::IsEditingState( mImpl->mEventData->mState )  )
+    if(EventData::IsEditingState(mImpl->mEventData->mState))
     {
       mImpl->mEventData->mUpdateCursorPosition = true;
     }
@@ -3076,15 +3064,15 @@ void Controller::ResetCursorPosition( CharacterIndex cursorIndex )
 
 void Controller::ResetScrollPosition()
 {
-  if( NULL != mImpl->mEventData )
+  if(NULL != mImpl->mEventData)
   {
     // Reset the scroll position.
-    mImpl->mModel->mScrollPosition = Vector2::ZERO;
+    mImpl->mModel->mScrollPosition                = Vector2::ZERO;
     mImpl->mEventData->mScrollAfterUpdatePosition = true;
   }
 }
 
-void Controller::SetControlInterface( ControlInterface* controlInterface )
+void Controller::SetControlInterface(ControlInterface* controlInterface)
 {
   mImpl->mControlInterface = controlInterface;
 }
@@ -3106,14 +3094,14 @@ Controller::Controller()
 {
 }
 
-Controller::Controller( ControlInterface* controlInterface )
-:Controller( controlInterface, nullptr, nullptr)
+Controller::Controller(ControlInterface* controlInterface)
+: Controller(controlInterface, nullptr, nullptr)
 {
 }
 
-Controller::Controller( ControlInterface* controlInterface,
-                        EditableControlInterface* editableControlInterface,
-                        SelectableControlInterface* selectableControlInterface )
+Controller::Controller(ControlInterface*           controlInterface,
+                       EditableControlInterface*   editableControlInterface,
+                       SelectableControlInterface* selectableControlInterface)
 : mImpl(new Controller::Impl(controlInterface, editableControlInterface, selectableControlInterface))
 {
 }

diff --git a/dali-toolkit/internal/text/text-editable-control-interface.h b/dali-toolkit/internal/text/text-editable-control-interface.h
index abfbb59..cda25df 100644 (file)
--- a/dali-toolkit/internal/text/text-editable-control-interface.h
+++ b/dali-toolkit/internal/text/text-editable-control-interface.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_TEXT_EDITABLE_CONTROL_INTERFACE_H
 
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,32 +23,31 @@
 
 namespace Dali
 {
-
 class Actor;
 
 namespace Toolkit
 {
-
 namespace Text
 {
-
 /**
  * @brief An interface that the Text::Controller uses to notify about text changes and add decoration to the text control.
  */
 class EditableControlInterface
 {
 public:
-
   /**
    * @brief Virtual destructor.
    */
   virtual ~EditableControlInterface()
-  {}
+  {
+  }
 
   /**
    * @brief Called to signal that text has been inserted or deleted.
+   *
+   * @param[in] immediate If true, it immediately emits the signal, if false, only emits once the signal when OnRelayout() is called next time.
    */
-  virtual void TextChanged() = 0;
+  virtual void TextChanged(bool immediate) = 0;
 
   /**
    * @brief Called when the number of characters to be inserted exceeds the maximum limit
@@ -60,7 +59,7 @@ public:
    *
    * @param[in] inputStyleMask Mask with the bits of the input style that has changed.
    */
-  virtual void InputStyleChanged( InputStyle::Mask inputStyleMask ) = 0;
+  virtual void InputStyleChanged(InputStyle::Mask inputStyleMask) = 0;
 
   /**
    * @brief Add a decoration.
@@ -68,7 +67,7 @@ public:
    * @param[in] decoration The actor displaying a decoration.
    * @param[in] needsClipping Whether the actor needs clipping.
    */
-  virtual void AddDecoration( Actor& actor, bool needsClipping ) = 0;
+  virtual void AddDecoration(Actor& actor, bool needsClipping) = 0;
 
   /**
    * @brief Editable status (on/off).
@@ -82,7 +81,7 @@ public:
    *
    * @param[in] editable The editable status.
    */
-  virtual void SetEditable( bool editable ) = 0;
+  virtual void SetEditable(bool editable) = 0;
 };
 
 } // namespace Text