X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Ftext-controls%2Ftext-field-impl.cpp;h=fe01e4630893686d4f25438caee1e50d85f20c70;hp=47b32e95c1873041e4f84119cf691d3602fca23d;hb=refs%2Fchanges%2F46%2F265846%2F1;hpb=e75380e149afca3f36217c727b9d5eb52a6d49ff

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 47b32e9..fe01e46 100644
--- a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
+++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
@@ -21,21 +21,22 @@
 // EXTERNAL INCLUDES
 #include <dali/devel-api/actors/actor-devel.h>
 #include <dali/devel-api/adaptor-framework/key-devel.h>
-#include <dali/devel-api/adaptor-framework/window-devel.h>
 #include <dali/devel-api/common/stage.h>
 #include <dali/devel-api/object/property-helper-devel.h>
 #include <dali/integration-api/debug.h>
+#include <dali/public-api/actors/layer.h>
 #include <dali/public-api/adaptor-framework/key.h>
 #include <dali/public-api/common/dali-common.h>
 #include <dali/public-api/object/type-registry-helper.h>
 #include <cstring>
 
 // INTERNAL INCLUDES
-#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 #include <dali-toolkit/devel-api/controls/control-devel.h>
 #include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 #include <dali-toolkit/devel-api/text/rendering-backend.h>
+#include <dali-toolkit/internal/controls/text-controls/common-text-utils.h>
+#include <dali-toolkit/internal/controls/text-controls/text-field-property-handler.h>
 #include <dali-toolkit/internal/styling/style-manager-impl.h>
 #include <dali-toolkit/internal/text/rendering/text-backend.h>
 #include <dali-toolkit/internal/text/text-effects-style.h>
@@ -49,6 +50,10 @@
 
 using namespace Dali::Toolkit::Text;
 
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gTextFieldLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
+#endif
+
 namespace Dali
 {
 namespace Toolkit
@@ -57,10 +62,6 @@ namespace Internal
 {
 namespace // unnamed namespace
 {
-#if defined(DEBUG_ENABLED)
-Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
-#endif
-
 const unsigned int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
 } // unnamed namespace
 
@@ -137,30 +138,67 @@ DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "selectedTextEnd"
 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "enableEditing",                    BOOLEAN,   ENABLE_EDITING                      )
 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "fontSizeScale",                    FLOAT,     FONT_SIZE_SCALE                     )
 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "primaryCursorPosition",            INTEGER,   PRIMARY_CURSOR_POSITION             )
-
-DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "textChanged",       SIGNAL_TEXT_CHANGED       )
-DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "maxLengthReached",  SIGNAL_MAX_LENGTH_REACHED )
-DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED)
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "grabHandleColor",                  VECTOR4,   GRAB_HANDLE_COLOR                   )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "inputFilter",                      MAP,       INPUT_FILTER                        )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "ellipsisPosition",                 INTEGER,   ELLIPSIS_POSITION                   )
+
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "textChanged",           SIGNAL_TEXT_CHANGED           )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "maxLengthReached",      SIGNAL_MAX_LENGTH_REACHED     )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "inputStyleChanged",     SIGNAL_INPUT_STYLE_CHANGED    )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "anchorClicked",         SIGNAL_ANCHOR_CLICKED         )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "inputFiltered",         SIGNAL_INPUT_FILTERED         )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "cursorPositionChanged", SIGNAL_CURSOR_POSITION_CHANGED)
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "selectionChanged",      SIGNAL_SELECTION_CHANGED      )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "selectionCleared",      SIGNAL_SELECTION_CLEARED      )
 
 DALI_TYPE_REGISTRATION_END()
 // clang-format on
 
-const char* const IMAGE_MAP_FILENAME_STRING = "filename";
-
-/// Retrieves a filename from a value that is a Property::Map
-std::string GetImageFileNameFromPropertyValue(const Property::Value& value)
+Toolkit::TextField::InputStyle::Mask ConvertInputStyle(Text::InputStyle::Mask inputStyleMask)
 {
-  std::string          filename;
-  const Property::Map* map = value.GetMap();
-  if(map)
+  Toolkit::TextField::InputStyle::Mask fieldInputStyleMask = Toolkit::TextField::InputStyle::NONE;
+
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_COLOR))
   {
-    const Property::Value* filenameValue = map->Find(IMAGE_MAP_FILENAME_STRING);
-    if(filenameValue)
-    {
-      filenameValue->Get(filename);
-    }
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::COLOR);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_FAMILY))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_FAMILY);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_POINT_SIZE))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::POINT_SIZE);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WEIGHT))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WIDTH))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_SLANT))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_UNDERLINE))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::UNDERLINE);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_SHADOW))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::SHADOW);
   }
-  return filename;
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_EMBOSS))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::EMBOSS);
+  }
+  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_OUTLINE))
+  {
+    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::OUTLINE);
+  }
+  return fieldInputStyleMask;
 }
 
 } // namespace
@@ -184,578 +222,12 @@ void TextField::SetProperty(BaseObject* object, Property::Index index, const Pro
 {
   Toolkit::TextField textField = Toolkit::TextField::DownCast(Dali::BaseHandle(object));
 
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField SetProperty\n");
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField SetProperty\n");
 
   if(textField)
   {
-    TextField& impl(GetImpl(textField));
-    DALI_ASSERT_DEBUG(impl.mController && "No text contoller");
-    DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
-
-    switch(index)
-    {
-      case Toolkit::DevelTextField::Property::RENDERING_BACKEND:
-      {
-        int backend = value.Get<int>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p RENDERING_BACKEND %d\n", impl.mController.Get(), backend);
-
-#ifndef ENABLE_VECTOR_BASED_TEXT_RENDERING
-        if(DevelText::RENDERING_VECTOR_BASED == backend)
-        {
-          backend = TextAbstraction::BITMAP_GLYPH; // Fallback to bitmap-based rendering
-        }
-#endif
-        if(impl.mRenderingBackend != backend)
-        {
-          impl.mRenderingBackend = backend;
-          impl.mRenderer.Reset();
-
-          // When using the vector-based rendering, the size of the GLyphs are different
-          TextAbstraction::GlyphType glyphType = (DevelText::RENDERING_VECTOR_BASED == impl.mRenderingBackend) ? TextAbstraction::VECTOR_GLYPH : TextAbstraction::BITMAP_GLYPH;
-          impl.mController->SetGlyphType(glyphType);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::TEXT:
-      {
-        const std::string& text = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p TEXT %s\n", impl.mController.Get(), text.c_str());
-
-        impl.mController->SetText(text);
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
-      {
-        const std::string& text = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PLACEHOLDER_TEXT %s\n", impl.mController.Get(), text.c_str());
-
-        impl.mController->SetPlaceholderText(Controller::PLACEHOLDER_TYPE_INACTIVE, text);
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED:
-      {
-        const std::string& text = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PLACEHOLDER_TEXT_FOCUSED %s\n", impl.mController.Get(), text.c_str());
-
-        impl.mController->SetPlaceholderText(Controller::PLACEHOLDER_TYPE_ACTIVE, text);
-        break;
-      }
-      case Toolkit::TextField::Property::FONT_FAMILY:
-      {
-        const std::string& fontFamily = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
-        impl.mController->SetDefaultFontFamily(fontFamily);
-        break;
-      }
-      case Toolkit::TextField::Property::FONT_STYLE:
-      {
-        SetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::POINT_SIZE:
-      {
-        const float pointSize = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p POINT_SIZE %f\n", impl.mController.Get(), pointSize);
-
-        if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE), pointSize))
-        {
-          impl.mController->SetDefaultFontSize(pointSize, Text::Controller::POINT_SIZE);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::MAX_LENGTH:
-      {
-        const int max = value.Get<int>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p MAX_LENGTH %d\n", impl.mController.Get(), max);
-
-        impl.mController->SetMaximumNumberOfCharacters(max);
-        break;
-      }
-      case Toolkit::TextField::Property::EXCEED_POLICY:
-      {
-        impl.mExceedPolicy = value.Get<int>();
-
-        if(Dali::Toolkit::TextField::EXCEED_POLICY_CLIP == impl.mExceedPolicy)
-        {
-          impl.EnableClipping();
-        }
-        else
-        {
-          UnparentAndReset(impl.mStencil);
-        }
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
-      {
-        Text::HorizontalAlignment::Type alignment(static_cast<Text::HorizontalAlignment::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
-        if(GetHorizontalAlignmentEnumeration(value, alignment))
-        {
-          DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p HORIZONTAL_ALIGNMENT %d\n", impl.mController.Get(), alignment);
-          impl.mController->SetHorizontalAlignment(alignment);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
-      {
-        Toolkit::Text::VerticalAlignment::Type alignment(static_cast<Text::VerticalAlignment::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
-        if(GetVerticalAlignmentEnumeration(value, alignment))
-        {
-          impl.mController->SetVerticalAlignment(alignment);
-          DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p VERTICAL_ALIGNMENT %d\n", impl.mController.Get(), alignment);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::TEXT_COLOR:
-      {
-        const Vector4& textColor = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p TEXT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), textColor.r, textColor.g, textColor.b, textColor.a);
-
-        if(impl.mController->GetDefaultColor() != textColor)
-        {
-          impl.mController->SetDefaultColor(textColor);
-          impl.mController->SetInputColor(textColor);
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR:
-      {
-        const Vector4& textColor = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PLACEHOLDER_TEXT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), textColor.r, textColor.g, textColor.b, textColor.a);
-
-        if(impl.mController->GetPlaceholderTextColor() != textColor)
-        {
-          impl.mController->SetPlaceholderTextColor(textColor);
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
-      {
-        const Vector4& color = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PRIMARY_CURSOR_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
-
-        impl.mDecorator->SetCursorColor(PRIMARY_CURSOR, color);
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
-      {
-        const Vector4& color = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SECONDARY_CURSOR_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
-
-        impl.mDecorator->SetCursorColor(SECONDARY_CURSOR, color);
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
-      {
-        const bool enable = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p ENABLE_CURSOR_BLINK %d\n", impl.mController.Get(), enable);
-
-        impl.mController->SetEnableCursorBlink(enable);
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
-      {
-        const float interval = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_BLINK_INTERVAL %f\n", impl.mController.Get(), interval);
-
-        impl.mDecorator->SetCursorBlinkInterval(interval);
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
-      {
-        const float duration = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_BLINK_DURATION %f\n", impl.mController.Get(), duration);
-
-        impl.mDecorator->SetCursorBlinkDuration(duration);
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_WIDTH:
-      {
-        const int width = value.Get<int>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_WIDTH %d\n", impl.mController.Get(), width);
-
-        impl.mDecorator->SetCursorWidth(width);
-        impl.mController->GetLayoutEngine().SetCursorWidth(width);
-        break;
-      }
-      case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
-      {
-        const std::string imageFileName = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p GRAB_HANDLE_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
-
-        if(imageFileName.size())
-        {
-          impl.mDecorator->SetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_RELEASED, imageFileName);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
-      {
-        const std::string imageFileName = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p GRAB_HANDLE_PRESSED_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
-
-        if(imageFileName.size())
-        {
-          impl.mDecorator->SetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_PRESSED, imageFileName);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SCROLL_THRESHOLD:
-      {
-        const float threshold = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p SCROLL_THRESHOLD %f\n", impl.mController.Get(), threshold);
-
-        impl.mDecorator->SetScrollThreshold(threshold);
-        break;
-      }
-      case Toolkit::TextField::Property::SCROLL_SPEED:
-      {
-        const float speed = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p SCROLL_SPEED %f\n", impl.mController.Get(), speed);
-
-        impl.mDecorator->SetScrollSpeed(speed);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
-      {
-        const std::string filename = GetImageFileNameFromPropertyValue(value);
-
-        if(filename.size())
-        {
-          impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, filename);
-          impl.RequestTextRelayout();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
-      {
-        const Vector4 color = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SELECTION_HIGHLIGHT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
-
-        impl.mDecorator->SetHighlightColor(color);
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
-      {
-        const Rect<int> box = value.Get<Rect<int> >();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p DECORATION_BOUNDING_BOX %d,%d %dx%d\n", impl.mController.Get(), box.x, box.y, box.width, box.height);
-
-        impl.mDecorator->SetBoundingBox(box);
-        impl.RequestTextRelayout();
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_METHOD_SETTINGS:
-      {
-        const Property::Map* map = value.GetMap();
-        if(map)
-        {
-          impl.mInputMethodOptions.ApplyProperty(*map);
-        }
-        impl.mController->SetInputModePassword(impl.mInputMethodOptions.IsPassword());
-
-        Toolkit::Control control = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
-        if(control == textField)
-        {
-          impl.mInputMethodContext.ApplyOptions(impl.mInputMethodOptions);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_COLOR:
-      {
-        const Vector4 inputColor = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p INPUT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), inputColor.r, inputColor.g, inputColor.b, inputColor.a);
-
-        impl.mController->SetInputColor(inputColor);
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_MARKUP:
-      {
-        const bool enableMarkup = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_MARKUP %d\n", impl.mController.Get(), enableMarkup);
-
-        impl.mController->SetMarkupProcessorEnabled(enableMarkup);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_FONT_FAMILY:
-      {
-        const std::string& fontFamily = value.Get<std::string>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p INPUT_FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
-        impl.mController->SetInputFontFamily(fontFamily);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_FONT_STYLE:
-      {
-        SetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_POINT_SIZE:
-      {
-        const float pointSize = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p INPUT_POINT_SIZE %f\n", impl.mController.Get(), pointSize);
-        impl.mController->SetInputFontPointSize(pointSize);
-        break;
-      }
-      case Toolkit::TextField::Property::UNDERLINE:
-      {
-        const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_UNDERLINE:
-      {
-        const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::SHADOW:
-      {
-        const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_SHADOW:
-      {
-        const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::EMBOSS:
-      {
-        const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_EMBOSS:
-      {
-        const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::OUTLINE:
-      {
-        const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_OUTLINE:
-      {
-        const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        if(update)
-        {
-          impl.mRenderer.Reset();
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS:
-      {
-        const Property::Map* map = value.GetMap();
-        if(map)
-        {
-          impl.mController->SetHiddenInputOption(*map);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::PIXEL_SIZE:
-      {
-        const float pixelSize = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize);
-
-        if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE), pixelSize))
-        {
-          impl.mController->SetDefaultFontSize(pixelSize, Text::Controller::PIXEL_SIZE);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_SELECTION:
-      {
-        const bool enableSelection = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_SELECTION %d\n", impl.mController.Get(), enableSelection);
-        impl.mController->SetSelectionEnabled(enableSelection);
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER:
-      {
-        const Property::Map* map = value.GetMap();
-        if(map)
-        {
-          impl.mController->SetPlaceholderProperty(*map);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::ELLIPSIS:
-      {
-        const bool ellipsis = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ELLIPSIS %d\n", impl.mController.Get(), ellipsis);
-
-        impl.mController->SetTextElideEnabled(ellipsis);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION:
-      {
-        const bool shiftSelection = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_SHIFT_SELECTION %d\n", impl.mController.Get(), shiftSelection);
-
-        impl.mController->SetShiftSelectionEnabled(shiftSelection);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE:
-      {
-        const bool grabHandleEnabled = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_GRAB_HANDLE %d\n", impl.mController.Get(), grabHandleEnabled);
-
-        impl.mController->SetGrabHandleEnabled(grabHandleEnabled);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
-      {
-        impl.mController->SetMatchSystemLanguageDirection(value.Get<bool>());
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP:
-      {
-        const bool grabHandlePopupEnabled = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_GRAB_HANDLE_POPUP %d\n", impl.mController.Get(), grabHandlePopupEnabled);
-
-        impl.mController->SetGrabHandlePopupEnabled(grabHandlePopupEnabled);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::BACKGROUND:
-      {
-        const Vector4 backgroundColor = value.Get<Vector4>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p BACKGROUND %f,%f,%f,%f\n", impl.mController.Get(), backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a);
-
-        impl.mController->SetBackgroundEnabled(true);
-        impl.mController->SetBackgroundColor(backgroundColor);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
-      {
-        uint32_t start = static_cast<uint32_t>(value.Get<int>());
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_START %d\n", impl.mController.Get(), start);
-        impl.SetTextSelectionRange(&start, nullptr);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
-      {
-        uint32_t end = static_cast<uint32_t>(value.Get<int>());
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_END %d\n", impl.mController.Get(), end);
-        impl.SetTextSelectionRange(nullptr, &end);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_EDITING:
-      {
-        const bool editable = value.Get<bool>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_EDITING %d\n", impl.mController.Get(), editable);
-        impl.SetEditable(editable);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::FONT_SIZE_SCALE:
-      {
-        const float scale = value.Get<float>();
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p FONT_SIZE_SCALE %f\n", impl.mController.Get(), scale);
-
-        if(!Equals(impl.mController->GetFontSizeScale(), scale))
-        {
-          impl.mController->SetFontSizeScale(scale);
-        }
-        break;
-      }
-      case Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION:
-      {
-        uint32_t position = static_cast<uint32_t>(value.Get<int>());
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PRIMARY_CURSOR_POSITION %d\n", impl.mController.Get(), position);
-        if(impl.mController->SetPrimaryCursorPosition(position))
-        {
-          impl.SetKeyInputFocus();
-        }
-        break;
-      }
-    } // switch
-  }   // textfield
+    PropertyHandler::SetProperty(textField, index, value);
+  }
 }
 
 Property::Value TextField::GetProperty(BaseObject* object, Property::Index index)
@@ -766,345 +238,7 @@ Property::Value TextField::GetProperty(BaseObject* object, Property::Index index
 
   if(textField)
   {
-    TextField& impl(GetImpl(textField));
-    DALI_ASSERT_DEBUG(impl.mController && "No text contoller");
-    DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
-
-    switch(index)
-    {
-      case Toolkit::DevelTextField::Property::RENDERING_BACKEND:
-      {
-        value = impl.mRenderingBackend;
-        break;
-      }
-      case Toolkit::TextField::Property::TEXT:
-      {
-        std::string text;
-        impl.mController->GetText(text);
-        DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p returning text: %s\n", impl.mController.Get(), text.c_str());
-        value = text;
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
-      {
-        std::string text;
-        impl.mController->GetPlaceholderText(Controller::PLACEHOLDER_TYPE_INACTIVE, text);
-        value = text;
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED:
-      {
-        std::string text;
-        impl.mController->GetPlaceholderText(Controller::PLACEHOLDER_TYPE_ACTIVE, text);
-        value = text;
-        break;
-      }
-      case Toolkit::TextField::Property::FONT_FAMILY:
-      {
-        value = impl.mController->GetDefaultFontFamily();
-        break;
-      }
-      case Toolkit::TextField::Property::FONT_STYLE:
-      {
-        GetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::POINT_SIZE:
-      {
-        value = impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE);
-        break;
-      }
-      case Toolkit::TextField::Property::MAX_LENGTH:
-      {
-        value = impl.mController->GetMaximumNumberOfCharacters();
-        break;
-      }
-      case Toolkit::TextField::Property::EXCEED_POLICY:
-      {
-        value = impl.mExceedPolicy;
-        break;
-      }
-      case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
-      {
-        const char* name = Text::GetHorizontalAlignmentString(impl.mController->GetHorizontalAlignment());
-
-        if(name)
-        {
-          value = std::string(name);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
-      {
-        const char* name = Text::GetVerticalAlignmentString(impl.mController->GetVerticalAlignment());
-
-        if(name)
-        {
-          value = std::string(name);
-        }
-        break;
-      }
-      case Toolkit::TextField::Property::TEXT_COLOR:
-      {
-        value = impl.mController->GetDefaultColor();
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR:
-      {
-        value = impl.mController->GetPlaceholderTextColor();
-        break;
-      }
-      case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
-      {
-        value = impl.mDecorator->GetColor(PRIMARY_CURSOR);
-        break;
-      }
-      case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
-      {
-        value = impl.mDecorator->GetColor(SECONDARY_CURSOR);
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
-      {
-        value = impl.mController->GetEnableCursorBlink();
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
-      {
-        value = impl.mDecorator->GetCursorBlinkInterval();
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
-      {
-        value = impl.mDecorator->GetCursorBlinkDuration();
-        break;
-      }
-      case Toolkit::TextField::Property::CURSOR_WIDTH:
-      {
-        value = impl.mDecorator->GetCursorWidth();
-        break;
-      }
-      case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
-      {
-        value = impl.mDecorator->GetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_RELEASED);
-        break;
-      }
-      case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
-      {
-        value = impl.mDecorator->GetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_PRESSED);
-        break;
-      }
-      case Toolkit::TextField::Property::SCROLL_THRESHOLD:
-      {
-        value = impl.mDecorator->GetScrollThreshold();
-        break;
-      }
-      case Toolkit::TextField::Property::SCROLL_SPEED:
-      {
-        value = impl.mDecorator->GetScrollSpeed();
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
-      {
-        impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
-      {
-        impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
-      {
-        impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
-      {
-        impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
-      {
-        impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
-      {
-        impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED);
-        break;
-      }
-      case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
-      {
-        value = impl.mDecorator->GetHighlightColor();
-        break;
-      }
-      case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
-      {
-        Rect<int> boundingBox;
-        impl.mDecorator->GetBoundingBox(boundingBox);
-        value = boundingBox;
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_METHOD_SETTINGS:
-      {
-        Property::Map map;
-        impl.mInputMethodOptions.RetrieveProperty(map);
-        value = map;
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_COLOR:
-      {
-        value = impl.mController->GetInputColor();
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_MARKUP:
-      {
-        value = impl.mController->IsMarkupProcessorEnabled();
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_FONT_FAMILY:
-      {
-        value = impl.mController->GetInputFontFamily();
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_FONT_STYLE:
-      {
-        GetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_POINT_SIZE:
-      {
-        value = impl.mController->GetInputFontPointSize();
-        break;
-      }
-      case Toolkit::TextField::Property::UNDERLINE:
-      {
-        GetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_UNDERLINE:
-      {
-        GetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::SHADOW:
-      {
-        GetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_SHADOW:
-      {
-        GetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::EMBOSS:
-      {
-        GetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_EMBOSS:
-      {
-        GetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::OUTLINE:
-      {
-        GetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
-        break;
-      }
-      case Toolkit::TextField::Property::INPUT_OUTLINE:
-      {
-        GetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
-        break;
-      }
-      case Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS:
-      {
-        Property::Map map;
-        impl.mController->GetHiddenInputOption(map);
-        value = map;
-        break;
-      }
-      case Toolkit::TextField::Property::PIXEL_SIZE:
-      {
-        value = impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE);
-        break;
-      }
-      case Toolkit::TextField::Property::ENABLE_SELECTION:
-      {
-        value = impl.mController->IsSelectionEnabled();
-        break;
-      }
-      case Toolkit::TextField::Property::PLACEHOLDER:
-      {
-        Property::Map map;
-        impl.mController->GetPlaceholderProperty(map);
-        value = map;
-        break;
-      }
-      case Toolkit::TextField::Property::ELLIPSIS:
-      {
-        value = impl.mController->IsTextElideEnabled();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION:
-      {
-        value = impl.mController->IsShiftSelectionEnabled();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE:
-      {
-        value = impl.mController->IsGrabHandleEnabled();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
-      {
-        value = impl.mController->IsMatchSystemLanguageDirection();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP:
-      {
-        value = impl.mController->IsGrabHandlePopupEnabled();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::BACKGROUND:
-      {
-        value = impl.mController->GetBackgroundColor();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::SELECTED_TEXT:
-      {
-        value = impl.mController->GetSelectedText();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
-      {
-        Uint32Pair range = impl.GetTextSelectionRange();
-        value            = static_cast<int>(range.first);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
-      {
-        Uint32Pair range = impl.GetTextSelectionRange();
-        value            = static_cast<int>(range.second);
-        break;
-      }
-      case Toolkit::DevelTextField::Property::ENABLE_EDITING:
-      {
-        value = impl.IsEditable();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::FONT_SIZE_SCALE:
-      {
-        value = impl.mController->GetFontSizeScale();
-        break;
-      }
-      case Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION:
-      {
-        value = static_cast<int>(impl.mController->GetPrimaryCursorPosition());
-        break;
-      }
-    } //switch
+    value = PropertyHandler::GetProperty(textField, index);
   }
 
   return value;
@@ -1123,37 +257,75 @@ void TextField::SelectNone()
 {
   if(mController && mController->IsShowingRealText())
   {
-    mController->SelectNone();
+    mController->SelectNone();
+  }
+}
+
+void TextField::SelectText(const uint32_t start, const uint32_t end)
+{
+  if(mController && mController->IsShowingRealText())
+  {
+    mController->SelectText(start, end);
+    SetKeyInputFocus();
+  }
+}
+
+string TextField::GetSelectedText() const
+{
+  string selectedText = "";
+  if(mController && mController->IsShowingRealText())
+  {
+    selectedText = mController->GetSelectedText();
+  }
+  return selectedText;
+}
+
+void TextField::SetTextSelectionRange(const uint32_t* start, const uint32_t* end)
+{
+  if(mController && mController->IsShowingRealText())
+  {
+    mController->SetTextSelectionRange(start, end);
+    SetKeyInputFocus();
+  }
+}
+
+Uint32Pair TextField::GetTextSelectionRange() const
+{
+  Uint32Pair range;
+  if(mController && mController->IsShowingRealText())
+  {
+    range = mController->GetTextSelectionRange();
   }
+  return range;
 }
 
-string TextField::GetSelectedText() const
+string TextField::CopyText()
 {
-  string selectedText = "";
+  string copiedText = "";
   if(mController && mController->IsShowingRealText())
   {
-    selectedText = mController->GetSelectedText();
+    copiedText = mController->CopyText();
   }
-  return selectedText;
+  return copiedText;
 }
 
-void TextField::SetTextSelectionRange(const uint32_t* start, const uint32_t* end)
+string TextField::CutText()
 {
+  string cutText = "";
   if(mController && mController->IsShowingRealText())
   {
-    mController->SetTextSelectionRange(start, end);
-    SetKeyInputFocus();
+    cutText = mController->CutText();
   }
+  return cutText;
 }
 
-Uint32Pair TextField::GetTextSelectionRange() const
+void TextField::PasteText()
 {
-  Uint32Pair range;
-  if(mController && mController->IsShowingRealText())
+  if(mController)
   {
-    range = mController->GetTextSelectionRange();
+    SetKeyInputFocus(); //Giving focus to the field that was passed to the PasteText in case the passed field (current field) doesn't have focus.
+    mController->PasteText();
   }
-  return range;
 }
 
 InputMethodContext TextField::GetInputMethodContext()
@@ -1180,6 +352,46 @@ bool TextField::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface*
   {
     field.InputStyleChangedSignal().Connect(tracker, functor);
   }
+  else if(0 == strcmp(signalName.c_str(), SIGNAL_ANCHOR_CLICKED))
+  {
+    if(field)
+    {
+      Internal::TextField& fieldImpl(GetImpl(field));
+      fieldImpl.AnchorClickedSignal().Connect(tracker, functor);
+    }
+  }
+  else if(0 == strcmp(signalName.c_str(), SIGNAL_CURSOR_POSITION_CHANGED))
+  {
+    if(field)
+    {
+      Internal::TextField& fieldImpl(GetImpl(field));
+      fieldImpl.CursorPositionChangedSignal().Connect(tracker, functor);
+    }
+  }
+  else if(0 == strcmp(signalName.c_str(), SIGNAL_INPUT_FILTERED))
+  {
+    if(field)
+    {
+      Internal::TextField& fieldImpl(GetImpl(field));
+      fieldImpl.InputFilteredSignal().Connect(tracker, functor);
+    }
+  }
+  else if(0 == strcmp(signalName.c_str(), SIGNAL_SELECTION_CHANGED))
+  {
+    if(field)
+    {
+      Internal::TextField& fieldImpl(GetImpl(field));
+      fieldImpl.SelectionChangedSignal().Connect(tracker, functor);
+    }
+  }
+  else if(0 == strcmp(signalName.c_str(), SIGNAL_SELECTION_CLEARED))
+  {
+    if(field)
+    {
+      Internal::TextField& fieldImpl(GetImpl(field));
+      fieldImpl.SelectionClearedSignal().Connect(tracker, functor);
+    }
+  }
   else
   {
     // signalName does not match any signal
@@ -1204,11 +416,36 @@ Toolkit::TextField::InputStyleChangedSignalType& TextField::InputStyleChangedSig
   return mInputStyleChangedSignal;
 }
 
+DevelTextField::AnchorClickedSignalType& TextField::AnchorClickedSignal()
+{
+  return mAnchorClickedSignal;
+}
+
+DevelTextField::CursorPositionChangedSignalType& TextField::CursorPositionChangedSignal()
+{
+  return mCursorPositionChangedSignal;
+}
+
+DevelTextField::InputFilteredSignalType& TextField::InputFilteredSignal()
+{
+  return mInputFilteredSignal;
+}
+
+DevelTextField::SelectionChangedSignalType& TextField::SelectionChangedSignal()
+{
+  return mSelectionChangedSignal;
+}
+
+DevelTextField::SelectionClearedSignalType& TextField::SelectionClearedSignal()
+{
+  return mSelectionClearedSignal;
+}
+
 void TextField::OnInitialize()
 {
   Actor self = Self();
 
-  mController = Text::Controller::New(this, this, this);
+  mController = Text::Controller::New(this, this, this, this);
 
   // When using the vector-based rendering, the size of the GLyphs are different
   TextAbstraction::GlyphType glyphType = (DevelText::RENDERING_VECTOR_BASED == mRenderingBackend) ? TextAbstraction::VECTOR_GLYPH : TextAbstraction::BITMAP_GLYPH;
@@ -1241,9 +478,12 @@ void TextField::OnInitialize()
   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(stage.GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
   mController->SetLayoutDirection(layoutDirection);
 
+  self.LayoutDirectionChangedSignal().Connect(this, &TextField::OnLayoutDirectionChanged);
+
   // Forward input events to controller
   EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS));
   GetTapGestureDetector().SetMaximumTapsRequired(2);
+  GetTapGestureDetector().ReceiveAllTapEvents(true);
 
   self.TouchedSignal().Connect(this, &TextField::OnTouched);
 
@@ -1283,13 +523,13 @@ void TextField::OnInitialize()
 
 void TextField::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnStyleChange\n");
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnStyleChange\n");
 
   switch(change)
   {
     case StyleChange::DEFAULT_FONT_CHANGE:
     {
-      DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnStyleChange DEFAULT_FONT_CHANGE\n");
+      DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnStyleChange DEFAULT_FONT_CHANGE\n");
       const std::string& newFont = GetImpl(styleManager).GetDefaultFontFamily();
       // Property system did not set the font so should update it.
       mController->UpdateAfterFontChange(newFont);
@@ -1343,7 +583,7 @@ void TextField::ResizeActor(Actor& actor, const Vector2& size)
 
 void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField OnRelayout\n");
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField OnRelayout\n");
 
   Actor self = Self();
 
@@ -1353,15 +593,8 @@ void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
   Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom));
 
   // Support Right-To-Left of padding
-  Dali::LayoutDirection::Type layoutDirection;
-  if(mController->IsMatchSystemLanguageDirection())
-  {
-    layoutDirection = static_cast<Dali::LayoutDirection::Type>(DevelWindow::Get(self).GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
-  }
-  else
-  {
-    layoutDirection = static_cast<Dali::LayoutDirection::Type>(self.GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
-  }
+  Dali::LayoutDirection::Type layoutDirection = mController->GetLayoutDirection(self);
+
   if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
   {
     std::swap(padding.start, padding.end);
@@ -1378,12 +611,18 @@ void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
     ResizeActor(mActiveLayer, contentSize);
   }
 
+  // If there is text changed, callback is called.
+  if(mTextChanged)
+  {
+    EmitTextChangedSignal();
+  }
+
   const Text::Controller::UpdateTextType updateTextType = mController->Relayout(contentSize, layoutDirection);
 
   if((Text::Controller::NONE_UPDATED != updateTextType) ||
      !mRenderer)
   {
-    DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnRelayout %p Displaying new contents\n", mController.Get());
+    DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnRelayout %p Displaying new contents\n", mController.Get());
 
     if(mDecorator &&
        (Text::Controller::NONE_UPDATED != (Text::Controller::DECORATOR_UPDATED & updateTextType)))
@@ -1397,14 +636,21 @@ void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
     }
 
     RenderText(updateTextType);
+  }
 
-    // If there is text changed, callback is called.
-    if(mTextChanged)
-    {
-      Dali::Toolkit::TextField handle(GetOwner());
-      mTextChangedSignal.Emit(handle);
-      mTextChanged = false;
-    }
+  if(mCursorPositionChanged)
+  {
+    EmitCursorPositionChangedSignal();
+  }
+
+  if(mSelectionChanged)
+  {
+    EmitSelectionChangedSignal();
+  }
+
+  if(mSelectionCleared)
+  {
+    EmitSelectionClearedSignal();
   }
 
   // The text-field emits signals when the input style changes. These changes of style are
@@ -1427,113 +673,19 @@ void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
   }
 }
 
-Text::ControllerPtr TextField::getController()
+Text::ControllerPtr TextField::GetTextController()
 {
   return mController;
 }
 
 void TextField::RenderText(Text::Controller::UpdateTextType updateTextType)
 {
-  Actor renderableActor;
-
-  if(Text::Controller::NONE_UPDATED != (Text::Controller::MODEL_UPDATED & updateTextType))
-  {
-    if(mRenderer)
-    {
-      Dali::Toolkit::TextField handle = Dali::Toolkit::TextField(GetOwner());
-
-      renderableActor = mRenderer->Render(mController->GetView(),
-                                          handle,
-                                          Property::INVALID_INDEX, // Animatable property not supported
-                                          mAlignmentOffset,
-                                          DepthIndex::CONTENT);
-    }
-
-    if(renderableActor != mRenderableActor)
-    {
-      UnparentAndReset(mBackgroundActor);
-      UnparentAndReset(mRenderableActor);
-      mRenderableActor = renderableActor;
-
-      if(mRenderableActor)
-      {
-        mBackgroundActor = mController->CreateBackgroundActor();
-      }
-    }
-  }
-
-  if(mRenderableActor)
-  {
-    const Vector2& scrollOffset = mController->GetTextModel()->GetScrollPosition();
-
-    float renderableActorPositionX, renderableActorPositionY;
-
-    if(mStencil)
-    {
-      renderableActorPositionX = scrollOffset.x + mAlignmentOffset;
-      renderableActorPositionY = scrollOffset.y;
-    }
-    else
-    {
-      Extents padding;
-      padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
-
-      // Support Right-To-Left of padding
-      Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
-      if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
-      {
-        std::swap(padding.start, padding.end);
-      }
-
-      renderableActorPositionX = scrollOffset.x + mAlignmentOffset + padding.start;
-      renderableActorPositionY = scrollOffset.y + padding.top;
-    }
-
-    mRenderableActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY));
-
-    // Make sure the actors are parented correctly with/without clipping
-    Actor self = mStencil ? mStencil : Self();
-
-    Actor highlightActor;
-
-    for(std::vector<Actor>::iterator it    = mClippingDecorationActors.begin(),
-                                     endIt = mClippingDecorationActors.end();
-        it != endIt;
-        ++it)
-    {
-      self.Add(*it);
-      it->LowerToBottom();
-
-      if(it->GetProperty<std::string>(Dali::Actor::Property::NAME) == "HighlightActor")
-      {
-        highlightActor = *it;
-      }
-    }
-    mClippingDecorationActors.clear();
-
-    self.Add(mRenderableActor);
-
-    if(mBackgroundActor)
-    {
-      if(mDecorator && mDecorator->IsHighlightVisible())
-      {
-        self.Add(mBackgroundActor);
-        mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY)); // In text field's coords.
-        mBackgroundActor.LowerBelow(highlightActor);
-      }
-      else
-      {
-        mRenderableActor.Add(mBackgroundActor);
-        mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f)); // In renderable actor's coords.
-        mBackgroundActor.LowerToBottom();
-      }
-    }
-  }
+  CommonTextUtils::RenderText(Self(), mRenderer, mController, mDecorator, mAlignmentOffset, mRenderableActor, mBackgroundActor, mStencil, mClippingDecorationActors, updateTextType);
 }
 
 void TextField::OnKeyInputFocusGained()
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnKeyInputFocusGained %p\n", mController.Get());
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnKeyInputFocusGained %p\n", mController.Get());
   if(mInputMethodContext && IsEditable())
   {
     // All input panel properties, such as layout, return key type, and input hint, should be set before input panel activates (or shows).
@@ -1564,7 +716,7 @@ void TextField::OnKeyInputFocusGained()
 
 void TextField::OnKeyInputFocusLost()
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField:OnKeyInputFocusLost %p\n", mController.Get());
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField:OnKeyInputFocusLost %p\n", mController.Get());
   if(mInputMethodContext)
   {
     mInputMethodContext.StatusChangedSignal().Disconnect(this, &TextField::KeyboardStatusChanged);
@@ -1596,7 +748,7 @@ bool TextField::OnAccessibilityActivated()
 
 void TextField::OnTap(const TapGesture& gesture)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnTap %p\n", mController.Get());
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnTap %p\n", mController.Get());
   if(mInputMethodContext && IsEditable())
   {
     mInputMethodContext.Activate();
@@ -1606,6 +758,7 @@ void TextField::OnTap(const TapGesture& gesture)
   padding                   = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
   const Vector2& localPoint = gesture.GetLocalPoint();
   mController->TapEvent(gesture.GetNumberOfTaps(), localPoint.x - padding.start, localPoint.y - padding.top);
+  mController->AnchorEvent(localPoint.x - padding.start, localPoint.y - padding.top);
 
   SetKeyInputFocus();
 }
@@ -1631,7 +784,7 @@ void TextField::OnLongPress(const LongPressGesture& gesture)
 
 bool TextField::OnKeyEvent(const KeyEvent& event)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnKeyEvent %p keyCode %d\n", mController.Get(), event.GetKeyCode());
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnKeyEvent %p keyCode %d\n", mController.Get(), event.GetKeyCode());
 
   if(Dali::DALI_KEY_ESCAPE == event.GetKeyCode() && mController->ShouldClearFocusOnEscape())
   {
@@ -1687,17 +840,37 @@ void TextField::TextDeleted(unsigned int position, unsigned int length, const st
   }
 }
 
-void TextField::CaretMoved(unsigned int position)
+void TextField::CursorPositionChanged(unsigned int oldPosition, unsigned int newPosition)
 {
   if(Accessibility::IsUp())
   {
-    Control::Impl::GetAccessibilityObject(Self())->EmitTextCaretMoved(position);
+    Control::Impl::GetAccessibilityObject(Self())->EmitTextCursorMoved(newPosition);
+  }
+
+  if((oldPosition != newPosition) && !mCursorPositionChanged)
+  {
+    mCursorPositionChanged = true;
+    mOldPosition           = oldPosition;
+  }
+}
+
+void TextField::TextChanged(bool immediate)
+{
+  if(immediate) // Emits TextChangedSignal immediately
+  {
+    EmitTextChangedSignal();
+  }
+  else
+  {
+    mTextChanged = true;
   }
 }
 
-void TextField::TextChanged()
+void TextField::EmitTextChangedSignal()
 {
-  mTextChanged = true;
+  Dali::Toolkit::TextField handle(GetOwner());
+  mTextChangedSignal.Emit(handle);
+  mTextChanged = false;
 }
 
 void TextField::MaxLengthReached()
@@ -1709,51 +882,63 @@ void TextField::MaxLengthReached()
 void TextField::InputStyleChanged(Text::InputStyle::Mask inputStyleMask)
 {
   Dali::Toolkit::TextField handle(GetOwner());
+  mInputStyleChangedSignal.Emit(handle, ConvertInputStyle(inputStyleMask));
+}
 
-  Toolkit::TextField::InputStyle::Mask fieldInputStyleMask = Toolkit::TextField::InputStyle::NONE;
+void TextField::AnchorClicked(const std::string& href)
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mAnchorClickedSignal.Emit(handle, href.c_str(), href.length());
+}
 
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_COLOR))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::COLOR);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_FAMILY))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_FAMILY);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_POINT_SIZE))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::POINT_SIZE);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WEIGHT))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WIDTH))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_SLANT))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_UNDERLINE))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::UNDERLINE);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_SHADOW))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::SHADOW);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_EMBOSS))
-  {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::EMBOSS);
-  }
-  if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_OUTLINE))
+void TextField::EmitCursorPositionChangedSignal()
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mCursorPositionChangedSignal.Emit(handle, mOldPosition);
+  mCursorPositionChanged = false;
+}
+
+void TextField::InputFiltered(Toolkit::InputFilter::Property::Type type)
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mInputFilteredSignal.Emit(handle, type);
+}
+
+void TextField::EmitSelectionChangedSignal()
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mSelectionChangedSignal.Emit(handle, mOldSelectionStart, mOldSelectionEnd);
+  mSelectionChanged = false;
+}
+
+void TextField::EmitSelectionClearedSignal()
+{
+  Dali::Toolkit::TextField handle(GetOwner());
+  mSelectionClearedSignal.Emit(handle);
+  mSelectionCleared = false;
+}
+
+void TextField::SelectionChanged(uint32_t oldStart, uint32_t oldEnd, uint32_t newStart, uint32_t newEnd)
+{
+  if(((oldStart != newStart) || (oldEnd != newEnd)) && !mSelectionChanged)
   {
-    fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::OUTLINE);
-  }
+    if(newStart == newEnd)
+    {
+      mSelectionCleared = true;
+    }
+
+    mSelectionChanged  = true;
+    mOldSelectionStart = oldStart;
+    mOldSelectionEnd   = oldEnd;
 
-  mInputStyleChangedSignal.Emit(handle, fieldInputStyleMask);
+    if(mOldSelectionStart > mOldSelectionEnd)
+    {
+      //swap
+      uint32_t temp      = mOldSelectionStart;
+      mOldSelectionStart = mOldSelectionEnd;
+      mOldSelectionEnd   = temp;
+    }
+  }
 }
 
 void TextField::AddDecoration(Actor& actor, bool needsClipping)
@@ -1774,6 +959,18 @@ void TextField::AddDecoration(Actor& actor, bool needsClipping)
   }
 }
 
+void TextField::GetControlBackgroundColor(Vector4& color) const
+{
+  Property::Value propValue = Self().GetProperty(Toolkit::Control::Property::BACKGROUND);
+  Property::Map*  resultMap = propValue.GetMap();
+
+  Property::Value* colorValue = nullptr;
+  if(resultMap && (colorValue = resultMap->Find(ColorVisual::Property::MIX_COLOR)))
+  {
+    colorValue->Get(color);
+  }
+}
+
 void TextField::OnSceneConnect(Dali::Actor actor)
 {
   if(mHasBeenStaged)
@@ -1788,7 +985,7 @@ void TextField::OnSceneConnect(Dali::Actor actor)
 
 InputMethodContext::CallbackData TextField::OnInputMethodContextEvent(Dali::InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnInputMethodContextEvent %p eventName %d\n", mController.Get(), inputMethodContextEvent.eventName);
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::OnInputMethodContextEvent %p eventName %d\n", mController.Get(), inputMethodContextEvent.eventName);
   return mController->OnInputMethodContextEvent(inputMethodContext, inputMethodContextEvent);
 }
 
@@ -1797,8 +994,9 @@ void TextField::GetHandleImagePropertyValue(Property::Value& value, Text::Handle
   if(mDecorator)
   {
     Property::Map map;
-    map[IMAGE_MAP_FILENAME_STRING] = mDecorator->GetHandleImage(handleType, handleImageType);
-    value                          = map;
+    map[PropertyHandler::IMAGE_MAP_FILENAME_STRING] = mDecorator->GetHandleImage(handleType, handleImageType);
+
+    value = map;
   }
 }
 
@@ -1830,7 +1028,7 @@ void TextField::OnClipboardTextSelected(ClipboardEventNotifier& clipboard)
 
 void TextField::KeyboardStatusChanged(bool keyboardShown)
 {
-  DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown);
+  DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown);
 
   // Just hide the grab handle when keyboard is hidden.
   if(!keyboardShown)
@@ -1859,6 +1057,11 @@ bool TextField::OnTouched(Actor actor, const TouchEvent& touch)
   return false;
 }
 
+void TextField::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
+{
+  mController->ChangedLayoutDirection();
+}
+
 void TextField::OnIdleSignal()
 {
   // Emits the change of input style signals.
@@ -1875,7 +1078,13 @@ TextField::TextField()
   mRenderingBackend(DEFAULT_RENDERING_BACKEND),
   mExceedPolicy(Dali::Toolkit::TextField::EXCEED_POLICY_CLIP),
   mHasBeenStaged(false),
-  mTextChanged(false)
+  mTextChanged(false),
+  mCursorPositionChanged(false),
+  mSelectionChanged(false),
+  mSelectionCleared(false),
+  mOldPosition(0u),
+  mOldSelectionStart(0u),
+  mOldSelectionEnd(0u)
 {
 }
 
@@ -1891,60 +1100,64 @@ TextField::~TextField()
 
 std::string TextField::AccessibleImpl::GetName()
 {
-  auto slf = Toolkit::TextField::DownCast(self);
-  return slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  auto self = Toolkit::TextField::DownCast(Self());
+  return self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
 }
 
-std::string TextField::AccessibleImpl::GetText(size_t startOffset,
-                                               size_t endOffset)
+std::string TextField::AccessibleImpl::GetText(size_t startOffset, size_t endOffset)
 {
   if(endOffset <= startOffset)
+  {
     return {};
+  }
 
-  auto slf = Toolkit::TextField::DownCast(self);
-  auto txt =
-    slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
 
-  if(startOffset > txt.size() || endOffset > txt.size())
+  if(startOffset > text.size() || endOffset > text.size())
+  {
     return {};
+  }
 
-  return txt.substr(startOffset, endOffset - startOffset);
+  return text.substr(startOffset, endOffset - startOffset);
 }
 
 size_t TextField::AccessibleImpl::GetCharacterCount()
 {
-  auto slf = Toolkit::TextField::DownCast(self);
-  auto txt =
-    slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
 
-  return txt.size();
+  return text.size();
 }
 
-size_t TextField::AccessibleImpl::GetCaretOffset()
+size_t TextField::AccessibleImpl::GetCursorOffset()
 {
-  auto slf = Toolkit::TextField::DownCast(self);
-  return Dali::Toolkit::GetImpl(slf).getController()->GetCursorPosition();
+  auto self = Toolkit::TextField::DownCast(Self());
+  return Dali::Toolkit::GetImpl(self).GetTextController()->GetCursorPosition();
 }
 
-bool TextField::AccessibleImpl::SetCaretOffset(size_t offset)
+bool TextField::AccessibleImpl::SetCursorOffset(size_t offset)
 {
-  auto slf = Toolkit::TextField::DownCast(self);
-  auto txt = slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
-  if(offset > txt.size())
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  if(offset > text.size())
+  {
     return false;
+  }
+
+  auto& selfImpl = Dali::Toolkit::GetImpl(self);
+  selfImpl.GetTextController()->ResetCursorPosition(offset);
+  selfImpl.RequestTextRelayout();
 
-  auto& slfImpl = Dali::Toolkit::GetImpl(slf);
-  slfImpl.getController()->ResetCursorPosition(offset);
-  slfImpl.RequestTextRelayout();
   return true;
 }
 
 Dali::Accessibility::Range TextField::AccessibleImpl::GetTextAtOffset(
   size_t offset, Dali::Accessibility::TextBoundary boundary)
 {
-  auto slf      = Toolkit::TextField::DownCast(self);
-  auto txt      = slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
-  auto txt_size = txt.size();
+  auto self     = Toolkit::TextField::DownCast(Self());
+  auto text     = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  auto textSize = text.size();
 
   auto range = Dali::Accessibility::Range{};
 
@@ -1952,62 +1165,78 @@ Dali::Accessibility::Range TextField::AccessibleImpl::GetTextAtOffset(
   {
     case Dali::Accessibility::TextBoundary::CHARACTER:
     {
-      if(offset < txt_size)
+      if(offset < textSize)
       {
-        range.content     = txt[offset];
+        range.content     = text[offset];
         range.startOffset = offset;
         range.endOffset   = offset + 1;
       }
+      break;
     }
-    break;
     case Dali::Accessibility::TextBoundary::WORD:
     case Dali::Accessibility::TextBoundary::LINE:
     {
-      auto txt_c_string = txt.c_str();
-      auto breaks       = std::vector<char>(txt_size, 0);
+      auto textString = text.c_str();
+      auto breaks     = std::vector<char>(textSize, 0);
+
       if(boundary == Dali::Accessibility::TextBoundary::WORD)
-        Accessibility::Accessible::FindWordSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data());
+      {
+        Accessibility::Accessible::FindWordSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
+      }
       else
-        Accessibility::Accessible::FindLineSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data());
+      {
+        Accessibility::Accessible::FindLineSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
+      }
+
       auto index   = 0u;
       auto counter = 0u;
-      while(index < txt_size && counter <= offset)
+      while(index < textSize && counter <= offset)
       {
         auto start = index;
         if(breaks[index])
         {
           while(breaks[index])
+          {
             index++;
+          }
           counter++;
         }
         else
         {
           if(boundary == Dali::Accessibility::TextBoundary::WORD)
+          {
             index++;
+          }
           if(boundary == Dali::Accessibility::TextBoundary::LINE)
+          {
             counter++;
+          }
         }
+
         if((counter > 0) && ((counter - 1) == offset))
         {
-          range.content     = txt.substr(start, index - start + 1);
+          range.content     = text.substr(start, index - start + 1);
           range.startOffset = start;
           range.endOffset   = index + 1;
         }
+
         if(boundary == Dali::Accessibility::TextBoundary::LINE)
+        {
           index++;
+        }
       }
+      break;
     }
-    break;
     case Dali::Accessibility::TextBoundary::SENTENCE:
     {
-      /* not supported by efl */
+      /* not supported by default */
+      break;
     }
-    break;
     case Dali::Accessibility::TextBoundary::PARAGRAPH:
     {
       /* Paragraph is not supported by libunibreak library */
+      break;
     }
-    break;
     default:
       break;
   }
@@ -2015,72 +1244,90 @@ Dali::Accessibility::Range TextField::AccessibleImpl::GetTextAtOffset(
   return range;
 }
 
-Dali::Accessibility::Range
-TextField::AccessibleImpl::GetSelection(size_t selectionNum)
+Dali::Accessibility::Range TextField::AccessibleImpl::GetRangeOfSelection(size_t selectionIndex)
 {
   // Since DALi supports only one selection indexes higher than 0 are ignored
-  if(selectionNum > 0)
+  if(selectionIndex > 0)
+  {
     return {};
+  }
 
-  auto        slf  = Toolkit::TextField::DownCast(self);
-  auto        ctrl = Dali::Toolkit::GetImpl(slf).getController();
-  std::string ret;
-  ctrl->RetrieveSelection(ret);
-  auto r = ctrl->GetSelectionIndexes();
+  auto        self       = Toolkit::TextField::DownCast(Self());
+  auto        controller = Dali::Toolkit::GetImpl(self).GetTextController();
+  std::string value{};
+  controller->RetrieveSelection(value);
+  auto indices = controller->GetSelectionIndexes();
 
-  return {static_cast<size_t>(r.first), static_cast<size_t>(r.second), ret};
+  return {static_cast<size_t>(indices.first), static_cast<size_t>(indices.second), value};
 }
 
-bool TextField::AccessibleImpl::RemoveSelection(size_t selectionNum)
+bool TextField::AccessibleImpl::RemoveSelection(size_t selectionIndex)
 {
   // Since DALi supports only one selection indexes higher than 0 are ignored
-  if(selectionNum > 0)
+  if(selectionIndex > 0)
+  {
     return false;
+  }
 
-  auto slf = Toolkit::TextField::DownCast(self);
-  Dali::Toolkit::GetImpl(slf).getController()->SetSelection(0, 0);
+  auto self = Toolkit::TextField::DownCast(Self());
+  Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(0, 0);
   return true;
 }
 
-bool TextField::AccessibleImpl::SetSelection(size_t selectionNum,
-                                             size_t startOffset,
-                                             size_t endOffset)
+bool TextField::AccessibleImpl::SetRangeOfSelection(size_t selectionIndex, size_t startOffset, size_t endOffset)
 {
   // Since DALi supports only one selection indexes higher than 0 are ignored
-  if(selectionNum > 0)
+  if(selectionIndex > 0)
+  {
+    return false;
+  }
+
+  auto self = Toolkit::TextField::DownCast(Self());
+  Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(startOffset, endOffset);
+  return true;
+}
+
+bool TextField::AccessibleImpl::CopyText(size_t startPosition, size_t endPosition)
+{
+  if(endPosition <= startPosition)
+  {
     return false;
+  }
+
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
 
-  auto slf = Toolkit::TextField::DownCast(self);
-  Dali::Toolkit::GetImpl(slf).getController()->SetSelection(startOffset,
-                                                            endOffset);
   return true;
 }
 
-bool TextField::AccessibleImpl::CopyText(size_t startPosition,
-                                         size_t endPosition)
+bool TextField::AccessibleImpl::CutText(size_t startPosition, size_t endPosition)
 {
   if(endPosition <= startPosition)
+  {
     return false;
+  }
 
-  auto slf = Toolkit::TextField::DownCast(self);
-  auto txt = slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
-  Dali::Toolkit::GetImpl(slf).getController()->CopyStringToClipboard(txt.substr(startPosition, endPosition - startPosition));
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+  Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
+
+  self.SetProperty(Toolkit::TextField::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
 
   return true;
 }
 
-bool TextField::AccessibleImpl::CutText(size_t startPosition,
-                                        size_t endPosition)
+bool TextField::AccessibleImpl::DeleteText(size_t startPosition, size_t endPosition)
 {
   if(endPosition <= startPosition)
+  {
     return false;
+  }
 
-  auto slf = Toolkit::TextField::DownCast(self);
-  auto txt = slf.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
-  Dali::Toolkit::GetImpl(slf).getController()->CopyStringToClipboard(txt.substr(startPosition, endPosition - startPosition));
+  auto self = Toolkit::TextField::DownCast(Self());
+  auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
 
-  slf.SetProperty(Toolkit::TextField::Property::TEXT,
-                  txt.substr(0, startPosition) + txt.substr(endPosition - startPosition, txt.size()));
+  self.SetProperty(Toolkit::TextField::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
 
   return true;
 }
@@ -2095,7 +1342,7 @@ Dali::Accessibility::States TextField::AccessibleImpl::CalculateStates()
   states[State::FOCUSABLE] = true;
 
   Toolkit::Control focusControl = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
-  if(self == focusControl)
+  if(mSelf == focusControl)
   {
     states[State::FOCUSED] = true;
   }
@@ -2103,6 +1350,25 @@ Dali::Accessibility::States TextField::AccessibleImpl::CalculateStates()
   return states;
 }
 
+bool TextField::AccessibleImpl::InsertText(size_t startPosition, std::string text)
+{
+  auto self         = Toolkit::TextField::DownCast(Self());
+  auto insertedText = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
+
+  insertedText.insert(startPosition, text);
+
+  self.SetProperty(Toolkit::TextField::Property::TEXT, std::move(insertedText));
+
+  return true;
+}
+
+bool TextField::AccessibleImpl::SetTextContents(std::string newContents)
+{
+  auto self = Toolkit::TextField::DownCast(Self());
+  self.SetProperty(Toolkit::TextField::Property::TEXT, std::move(newContents));
+  return true;
+}
+
 } // namespace Internal
 
 } // namespace Toolkit