dali-toolkit/internal/controls/text-controls/text-field-impl.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/text-controls/text-field-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/devel-api/adaptor-framework/key-devel.h>
  24 #include <dali/devel-api/common/stage.h>
  25 #include <dali/devel-api/object/property-helper-devel.h>
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/public-api/adaptor-framework/key.h>
  28 #include <dali/public-api/common/dali-common.h>
  29 #include <dali/public-api/object/type-registry-helper.h>
  30 #include <cstring>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  34 #include <dali-toolkit/devel-api/controls/control-devel.h>
  35 #include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
  36 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
  37 #include <dali-toolkit/devel-api/text/rendering-backend.h>
  38 #include <dali-toolkit/internal/styling/style-manager-impl.h>
  39 #include <dali-toolkit/internal/text/rendering/text-backend.h>
  40 #include <dali-toolkit/internal/text/text-effects-style.h>
  41 #include <dali-toolkit/internal/text/text-enumerations-impl.h>
  42 #include <dali-toolkit/internal/text/text-font-style.h>
  43 #include <dali-toolkit/internal/text/text-view.h>
  44 #include <dali-toolkit/public-api/text/text-enumerations.h>
  45 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
  46 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  47 #include <dali/integration-api/adaptor-framework/adaptor.h>
  48
  49 using namespace Dali::Toolkit::Text;
  50
  51 namespace Dali
  52 {
  53 namespace Toolkit
  54 {
  55 namespace Internal
  56 {
  57 namespace // unnamed namespace
  58 {
  59 #if defined(DEBUG_ENABLED)
  60 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
  61 #endif
  62
  63 const unsigned int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
  64 } // unnamed namespace
  65
  66 namespace
  67 {
  68 // Type registration
  69 BaseHandle Create()
  70 {
  71   return Toolkit::TextField::New();
  72 }
  73
  74 // clang-format off
  75 // Setup properties, signals and actions using the type-registry.
  76 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TextField, Toolkit::Control, Create );
  77
  78 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "text",                             STRING,    TEXT                                )
  79 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "placeholderText",                  STRING,    PLACEHOLDER_TEXT                    )
  80 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "placeholderTextFocused",           STRING,    PLACEHOLDER_TEXT_FOCUSED            )
  81 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "fontFamily",                       STRING,    FONT_FAMILY                         )
  82 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "fontStyle",                        MAP,       FONT_STYLE                          )
  83 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "pointSize",                        FLOAT,     POINT_SIZE                          )
  84 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "maxLength",                        INTEGER,   MAX_LENGTH                          )
  85 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "exceedPolicy",                     INTEGER,   EXCEED_POLICY                       )
  86 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "horizontalAlignment",              STRING,    HORIZONTAL_ALIGNMENT                )
  87 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "verticalAlignment",                STRING,    VERTICAL_ALIGNMENT                  )
  88 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "textColor",                        VECTOR4,   TEXT_COLOR                          )
  89 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "placeholderTextColor",             VECTOR4,   PLACEHOLDER_TEXT_COLOR              )
  90 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "primaryCursorColor",               VECTOR4,   PRIMARY_CURSOR_COLOR                )
  91 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "secondaryCursorColor",             VECTOR4,   SECONDARY_CURSOR_COLOR              )
  92 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "enableCursorBlink",                BOOLEAN,   ENABLE_CURSOR_BLINK                 )
  93 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "cursorBlinkInterval",              FLOAT,     CURSOR_BLINK_INTERVAL               )
  94 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "cursorBlinkDuration",              FLOAT,     CURSOR_BLINK_DURATION               )
  95 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "cursorWidth",                      INTEGER,   CURSOR_WIDTH                        )
  96 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "grabHandleImage",                  STRING,    GRAB_HANDLE_IMAGE                   )
  97 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "grabHandlePressedImage",           STRING,    GRAB_HANDLE_PRESSED_IMAGE           )
  98 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "scrollThreshold",                  FLOAT,     SCROLL_THRESHOLD                    )
  99 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "scrollSpeed",                      FLOAT,     SCROLL_SPEED                        )
 100 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandleImageLeft",         MAP,       SELECTION_HANDLE_IMAGE_LEFT         )
 101 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandleImageRight",        MAP,       SELECTION_HANDLE_IMAGE_RIGHT        )
 102 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandlePressedImageLeft",  MAP,       SELECTION_HANDLE_PRESSED_IMAGE_LEFT )
 103 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandlePressedImageRight", MAP,       SELECTION_HANDLE_PRESSED_IMAGE_RIGHT)
 104 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandleMarkerImageLeft",   MAP,       SELECTION_HANDLE_MARKER_IMAGE_LEFT  )
 105 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHandleMarkerImageRight",  MAP,       SELECTION_HANDLE_MARKER_IMAGE_RIGHT )
 106 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "selectionHighlightColor",          VECTOR4,   SELECTION_HIGHLIGHT_COLOR           )
 107 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "decorationBoundingBox",            RECTANGLE, DECORATION_BOUNDING_BOX             )
 108 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputMethodSettings",              MAP,       INPUT_METHOD_SETTINGS               )
 109 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputColor",                       VECTOR4,   INPUT_COLOR                         )
 110 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "enableMarkup",                     BOOLEAN,   ENABLE_MARKUP                       )
 111 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputFontFamily",                  STRING,    INPUT_FONT_FAMILY                   )
 112 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputFontStyle",                   MAP,       INPUT_FONT_STYLE                    )
 113 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputPointSize",                   FLOAT,     INPUT_POINT_SIZE                    )
 114 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "underline",                        MAP,       UNDERLINE                           )
 115 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputUnderline",                   MAP,       INPUT_UNDERLINE                     )
 116 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "shadow",                           MAP,       SHADOW                              )
 117 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputShadow",                      MAP,       INPUT_SHADOW                        )
 118 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "emboss",                           MAP,       EMBOSS                              )
 119 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputEmboss",                      MAP,       INPUT_EMBOSS                        )
 120 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "outline",                          MAP,       OUTLINE                             )
 121 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "inputOutline",                     MAP,       INPUT_OUTLINE                       )
 122 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "hiddenInputSettings",              MAP,       HIDDEN_INPUT_SETTINGS               )
 123 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "pixelSize",                        FLOAT,     PIXEL_SIZE                          )
 124 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "enableSelection",                  BOOLEAN,   ENABLE_SELECTION                    )
 125 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "placeholder",                      MAP,       PLACEHOLDER                         )
 126 DALI_PROPERTY_REGISTRATION(Toolkit,                 TextField, "ellipsis",                         BOOLEAN,   ELLIPSIS                            )
 127 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "enableShiftSelection",             BOOLEAN,   ENABLE_SHIFT_SELECTION              )
 128 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "enableGrabHandle",                 BOOLEAN,   ENABLE_GRAB_HANDLE                  )
 129 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "matchSystemLanguageDirection",     BOOLEAN,   MATCH_SYSTEM_LANGUAGE_DIRECTION     )
 130 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "enableGrabHandlePopup",            BOOLEAN,   ENABLE_GRAB_HANDLE_POPUP            )
 131 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "textBackground",                   VECTOR4,   BACKGROUND                          )
 132 DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY(Toolkit, TextField, "selectedText",                     STRING,    SELECTED_TEXT                       )
 133 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "renderingBackend",                 INTEGER,   RENDERING_BACKEND                   )
 134 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "selectedTextStart",                INTEGER,   SELECTED_TEXT_START                 )
 135 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "selectedTextEnd",                  INTEGER,   SELECTED_TEXT_END                   )
 136 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "enableEditing",                    BOOLEAN,   ENABLE_EDITING                      )
 137 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "fontSizeScale",                    FLOAT,     FONT_SIZE_SCALE                     )
 138 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "primaryCursorPosition",            INTEGER,   PRIMARY_CURSOR_POSITION             )
 139 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "grabHandleColor",                  VECTOR4,   GRAB_HANDLE_COLOR                   )
 140 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "inputFilter",                      MAP,       INPUT_FILTER                        )
 141 DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit,           TextField, "ellipsisPosition",                 INTEGER,   ELLIPSIS_POSITION                   )
 142
 143 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "textChanged",           SIGNAL_TEXT_CHANGED           )
 144 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "maxLengthReached",      SIGNAL_MAX_LENGTH_REACHED     )
 145 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "inputStyleChanged",     SIGNAL_INPUT_STYLE_CHANGED    )
 146 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "anchorClicked",         SIGNAL_ANCHOR_CLICKED         )
 147 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "inputFiltered",         SIGNAL_INPUT_FILTERED         )
 148 DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "cursorPositionChanged", SIGNAL_CURSOR_POSITION_CHANGED)
 149
 150 DALI_TYPE_REGISTRATION_END()
 151 // clang-format on
 152
 153 const char* const IMAGE_MAP_FILENAME_STRING = "filename";
 154
 155 /// Retrieves a filename from a value that is a Property::Map
 156 std::string GetImageFileNameFromPropertyValue(const Property::Value& value)
 157 {
 158   std::string          filename;
 159   const Property::Map* map = value.GetMap();
 160   if(map)
 161   {
 162     const Property::Value* filenameValue = map->Find(IMAGE_MAP_FILENAME_STRING);
 163     if(filenameValue)
 164     {
 165       filenameValue->Get(filename);
 166     }
 167   }
 168   return filename;
 169 }
 170
 171 } // namespace
 172
 173 Toolkit::TextField TextField::New()
 174 {
 175   // Create the implementation, temporarily owned by this handle on stack
 176   IntrusivePtr<TextField> impl = new TextField();
 177
 178   // Pass ownership to CustomActor handle
 179   Toolkit::TextField handle(*impl);
 180
 181   // Second-phase init of the implementation
 182   // This can only be done after the CustomActor connection has been made...
 183   impl->Initialize();
 184
 185   return handle;
 186 }
 187
 188 void TextField::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 189 {
 190   Toolkit::TextField textField = Toolkit::TextField::DownCast(Dali::BaseHandle(object));
 191
 192   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField SetProperty\n");
 193
 194   if(textField)
 195   {
 196     TextField& impl(GetImpl(textField));
 197     DALI_ASSERT_DEBUG(impl.mController && "No text contoller");
 198     DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
 199
 200     switch(index)
 201     {
 202       case Toolkit::DevelTextField::Property::RENDERING_BACKEND:
 203       {
 204         int backend = value.Get<int>();
 205         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p RENDERING_BACKEND %d\n", impl.mController.Get(), backend);
 206
 207 #ifndef ENABLE_VECTOR_BASED_TEXT_RENDERING
 208         if(DevelText::RENDERING_VECTOR_BASED == backend)
 209         {
 210           backend = TextAbstraction::BITMAP_GLYPH; // Fallback to bitmap-based rendering
 211         }
 212 #endif
 213         if(impl.mRenderingBackend != backend)
 214         {
 215           impl.mRenderingBackend = backend;
 216           impl.mRenderer.Reset();
 217
 218           // When using the vector-based rendering, the size of the GLyphs are different
 219           TextAbstraction::GlyphType glyphType = (DevelText::RENDERING_VECTOR_BASED == impl.mRenderingBackend) ? TextAbstraction::VECTOR_GLYPH : TextAbstraction::BITMAP_GLYPH;
 220           impl.mController->SetGlyphType(glyphType);
 221         }
 222         break;
 223       }
 224       case Toolkit::TextField::Property::TEXT:
 225       {
 226         const std::string& text = value.Get<std::string>();
 227         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p TEXT %s\n", impl.mController.Get(), text.c_str());
 228
 229         impl.mController->SetText(text);
 230         break;
 231       }
 232       case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
 233       {
 234         const std::string& text = value.Get<std::string>();
 235         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PLACEHOLDER_TEXT %s\n", impl.mController.Get(), text.c_str());
 236
 237         impl.mController->SetPlaceholderText(Controller::PLACEHOLDER_TYPE_INACTIVE, text);
 238         break;
 239       }
 240       case Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED:
 241       {
 242         const std::string& text = value.Get<std::string>();
 243         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PLACEHOLDER_TEXT_FOCUSED %s\n", impl.mController.Get(), text.c_str());
 244
 245         impl.mController->SetPlaceholderText(Controller::PLACEHOLDER_TYPE_ACTIVE, text);
 246         break;
 247       }
 248       case Toolkit::TextField::Property::FONT_FAMILY:
 249       {
 250         const std::string& fontFamily = value.Get<std::string>();
 251         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
 252         impl.mController->SetDefaultFontFamily(fontFamily);
 253         break;
 254       }
 255       case Toolkit::TextField::Property::FONT_STYLE:
 256       {
 257         SetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
 258         break;
 259       }
 260       case Toolkit::TextField::Property::POINT_SIZE:
 261       {
 262         const float pointSize = value.Get<float>();
 263         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p POINT_SIZE %f\n", impl.mController.Get(), pointSize);
 264
 265         if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE), pointSize))
 266         {
 267           impl.mController->SetDefaultFontSize(pointSize, Text::Controller::POINT_SIZE);
 268         }
 269         break;
 270       }
 271       case Toolkit::TextField::Property::MAX_LENGTH:
 272       {
 273         const int max = value.Get<int>();
 274         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p MAX_LENGTH %d\n", impl.mController.Get(), max);
 275
 276         impl.mController->SetMaximumNumberOfCharacters(max);
 277         break;
 278       }
 279       case Toolkit::TextField::Property::EXCEED_POLICY:
 280       {
 281         impl.mExceedPolicy = value.Get<int>();
 282
 283         if(Dali::Toolkit::TextField::EXCEED_POLICY_CLIP == impl.mExceedPolicy)
 284         {
 285           impl.EnableClipping();
 286         }
 287         else
 288         {
 289           UnparentAndReset(impl.mStencil);
 290         }
 291         impl.RequestTextRelayout();
 292         break;
 293       }
 294       case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
 295       {
 296         Text::HorizontalAlignment::Type alignment(static_cast<Text::HorizontalAlignment::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
 297         if(GetHorizontalAlignmentEnumeration(value, alignment))
 298         {
 299           DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p HORIZONTAL_ALIGNMENT %d\n", impl.mController.Get(), alignment);
 300           impl.mController->SetHorizontalAlignment(alignment);
 301         }
 302         break;
 303       }
 304       case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
 305       {
 306         Toolkit::Text::VerticalAlignment::Type alignment(static_cast<Text::VerticalAlignment::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
 307         if(GetVerticalAlignmentEnumeration(value, alignment))
 308         {
 309           impl.mController->SetVerticalAlignment(alignment);
 310           DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p VERTICAL_ALIGNMENT %d\n", impl.mController.Get(), alignment);
 311         }
 312         break;
 313       }
 314       case Toolkit::TextField::Property::TEXT_COLOR:
 315       {
 316         const Vector4& textColor = value.Get<Vector4>();
 317         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);
 318
 319         if(impl.mController->GetDefaultColor() != textColor)
 320         {
 321           impl.mController->SetDefaultColor(textColor);
 322           impl.mController->SetInputColor(textColor);
 323           impl.mRenderer.Reset();
 324         }
 325         break;
 326       }
 327       case Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR:
 328       {
 329         const Vector4& textColor = value.Get<Vector4>();
 330         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);
 331
 332         if(impl.mController->GetPlaceholderTextColor() != textColor)
 333         {
 334           impl.mController->SetPlaceholderTextColor(textColor);
 335           impl.mRenderer.Reset();
 336         }
 337         break;
 338       }
 339       case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
 340       {
 341         const Vector4& color = value.Get<Vector4>();
 342         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);
 343
 344         impl.mDecorator->SetCursorColor(PRIMARY_CURSOR, color);
 345         impl.RequestTextRelayout();
 346         break;
 347       }
 348       case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
 349       {
 350         const Vector4& color = value.Get<Vector4>();
 351         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);
 352
 353         impl.mDecorator->SetCursorColor(SECONDARY_CURSOR, color);
 354         impl.RequestTextRelayout();
 355         break;
 356       }
 357       case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
 358       {
 359         const bool enable = value.Get<bool>();
 360         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p ENABLE_CURSOR_BLINK %d\n", impl.mController.Get(), enable);
 361
 362         impl.mController->SetEnableCursorBlink(enable);
 363         impl.RequestTextRelayout();
 364         break;
 365       }
 366       case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
 367       {
 368         const float interval = value.Get<float>();
 369         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_BLINK_INTERVAL %f\n", impl.mController.Get(), interval);
 370
 371         impl.mDecorator->SetCursorBlinkInterval(interval);
 372         break;
 373       }
 374       case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
 375       {
 376         const float duration = value.Get<float>();
 377         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_BLINK_DURATION %f\n", impl.mController.Get(), duration);
 378
 379         impl.mDecorator->SetCursorBlinkDuration(duration);
 380         break;
 381       }
 382       case Toolkit::TextField::Property::CURSOR_WIDTH:
 383       {
 384         const int width = value.Get<int>();
 385         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p CURSOR_WIDTH %d\n", impl.mController.Get(), width);
 386
 387         impl.mDecorator->SetCursorWidth(width);
 388         impl.mController->GetLayoutEngine().SetCursorWidth(width);
 389         break;
 390       }
 391       case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
 392       {
 393         const std::string imageFileName = value.Get<std::string>();
 394         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p GRAB_HANDLE_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
 395
 396         if(imageFileName.size())
 397         {
 398           impl.mDecorator->SetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_RELEASED, imageFileName);
 399           impl.RequestTextRelayout();
 400         }
 401         break;
 402       }
 403       case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
 404       {
 405         const std::string imageFileName = value.Get<std::string>();
 406         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p GRAB_HANDLE_PRESSED_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
 407
 408         if(imageFileName.size())
 409         {
 410           impl.mDecorator->SetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_PRESSED, imageFileName);
 411           impl.RequestTextRelayout();
 412         }
 413         break;
 414       }
 415       case Toolkit::TextField::Property::SCROLL_THRESHOLD:
 416       {
 417         const float threshold = value.Get<float>();
 418         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p SCROLL_THRESHOLD %f\n", impl.mController.Get(), threshold);
 419
 420         impl.mDecorator->SetScrollThreshold(threshold);
 421         break;
 422       }
 423       case Toolkit::TextField::Property::SCROLL_SPEED:
 424       {
 425         const float speed = value.Get<float>();
 426         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField %p SCROLL_SPEED %f\n", impl.mController.Get(), speed);
 427
 428         impl.mDecorator->SetScrollSpeed(speed);
 429         break;
 430       }
 431       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
 432       {
 433         const std::string filename = GetImageFileNameFromPropertyValue(value);
 434
 435         if(filename.size())
 436         {
 437           impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, filename);
 438           impl.RequestTextRelayout();
 439         }
 440         break;
 441       }
 442       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 443       {
 444         const std::string filename = GetImageFileNameFromPropertyValue(value);
 445
 446         if(filename.size())
 447         {
 448           impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, filename);
 449           impl.RequestTextRelayout();
 450         }
 451         break;
 452       }
 453       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 454       {
 455         const std::string filename = GetImageFileNameFromPropertyValue(value);
 456
 457         if(filename.size())
 458         {
 459           impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, filename);
 460           impl.RequestTextRelayout();
 461         }
 462         break;
 463       }
 464       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 465       {
 466         const std::string filename = GetImageFileNameFromPropertyValue(value);
 467
 468         if(filename.size())
 469         {
 470           impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, filename);
 471           impl.RequestTextRelayout();
 472         }
 473         break;
 474       }
 475       case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 476       {
 477         const std::string filename = GetImageFileNameFromPropertyValue(value);
 478
 479         if(filename.size())
 480         {
 481           impl.mDecorator->SetHandleImage(LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, filename);
 482           impl.RequestTextRelayout();
 483         }
 484         break;
 485       }
 486       case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 487       {
 488         const std::string filename = GetImageFileNameFromPropertyValue(value);
 489
 490         if(filename.size())
 491         {
 492           impl.mDecorator->SetHandleImage(RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, filename);
 493           impl.RequestTextRelayout();
 494         }
 495         break;
 496       }
 497       case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
 498       {
 499         const Vector4 color = value.Get<Vector4>();
 500         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);
 501
 502         impl.mDecorator->SetHighlightColor(color);
 503         impl.RequestTextRelayout();
 504         break;
 505       }
 506       case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
 507       {
 508         const Rect<int> box = value.Get<Rect<int> >();
 509         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);
 510
 511         impl.mDecorator->SetBoundingBox(box);
 512         impl.RequestTextRelayout();
 513         break;
 514       }
 515       case Toolkit::TextField::Property::INPUT_METHOD_SETTINGS:
 516       {
 517         const Property::Map* map = value.GetMap();
 518         if(map)
 519         {
 520           impl.mInputMethodOptions.ApplyProperty(*map);
 521         }
 522         impl.mController->SetInputModePassword(impl.mInputMethodOptions.IsPassword());
 523
 524         Toolkit::Control control = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
 525         if(control == textField)
 526         {
 527           impl.mInputMethodContext.ApplyOptions(impl.mInputMethodOptions);
 528         }
 529         break;
 530       }
 531       case Toolkit::TextField::Property::INPUT_COLOR:
 532       {
 533         const Vector4 inputColor = value.Get<Vector4>();
 534         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);
 535
 536         impl.mController->SetInputColor(inputColor);
 537         break;
 538       }
 539       case Toolkit::TextField::Property::ENABLE_MARKUP:
 540       {
 541         const bool enableMarkup = value.Get<bool>();
 542         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_MARKUP %d\n", impl.mController.Get(), enableMarkup);
 543
 544         impl.mController->SetMarkupProcessorEnabled(enableMarkup);
 545         break;
 546       }
 547       case Toolkit::TextField::Property::INPUT_FONT_FAMILY:
 548       {
 549         const std::string& fontFamily = value.Get<std::string>();
 550         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p INPUT_FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
 551         impl.mController->SetInputFontFamily(fontFamily);
 552         break;
 553       }
 554       case Toolkit::TextField::Property::INPUT_FONT_STYLE:
 555       {
 556         SetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
 557         break;
 558       }
 559       case Toolkit::TextField::Property::INPUT_POINT_SIZE:
 560       {
 561         const float pointSize = value.Get<float>();
 562         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p INPUT_POINT_SIZE %f\n", impl.mController.Get(), pointSize);
 563         impl.mController->SetInputFontPointSize(pointSize);
 564         break;
 565       }
 566       case Toolkit::TextField::Property::UNDERLINE:
 567       {
 568         const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 569         if(update)
 570         {
 571           impl.mRenderer.Reset();
 572         }
 573         break;
 574       }
 575       case Toolkit::TextField::Property::INPUT_UNDERLINE:
 576       {
 577         const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 578         if(update)
 579         {
 580           impl.mRenderer.Reset();
 581         }
 582         break;
 583       }
 584       case Toolkit::TextField::Property::SHADOW:
 585       {
 586         const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 587         if(update)
 588         {
 589           impl.mRenderer.Reset();
 590         }
 591         break;
 592       }
 593       case Toolkit::TextField::Property::INPUT_SHADOW:
 594       {
 595         const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
 596         if(update)
 597         {
 598           impl.mRenderer.Reset();
 599         }
 600         break;
 601       }
 602       case Toolkit::TextField::Property::EMBOSS:
 603       {
 604         const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 605         if(update)
 606         {
 607           impl.mRenderer.Reset();
 608         }
 609         break;
 610       }
 611       case Toolkit::TextField::Property::INPUT_EMBOSS:
 612       {
 613         const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
 614         if(update)
 615         {
 616           impl.mRenderer.Reset();
 617         }
 618         break;
 619       }
 620       case Toolkit::TextField::Property::OUTLINE:
 621       {
 622         const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 623         if(update)
 624         {
 625           impl.mRenderer.Reset();
 626         }
 627         break;
 628       }
 629       case Toolkit::TextField::Property::INPUT_OUTLINE:
 630       {
 631         const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 632         if(update)
 633         {
 634           impl.mRenderer.Reset();
 635         }
 636         break;
 637       }
 638       case Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS:
 639       {
 640         const Property::Map* map = value.GetMap();
 641         if(map)
 642         {
 643           impl.mController->SetHiddenInputOption(*map);
 644         }
 645         break;
 646       }
 647       case Toolkit::TextField::Property::PIXEL_SIZE:
 648       {
 649         const float pixelSize = value.Get<float>();
 650         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize);
 651
 652         if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE), pixelSize))
 653         {
 654           impl.mController->SetDefaultFontSize(pixelSize, Text::Controller::PIXEL_SIZE);
 655         }
 656         break;
 657       }
 658       case Toolkit::TextField::Property::ENABLE_SELECTION:
 659       {
 660         const bool enableSelection = value.Get<bool>();
 661         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_SELECTION %d\n", impl.mController.Get(), enableSelection);
 662         impl.mController->SetSelectionEnabled(enableSelection);
 663         break;
 664       }
 665       case Toolkit::TextField::Property::PLACEHOLDER:
 666       {
 667         const Property::Map* map = value.GetMap();
 668         if(map)
 669         {
 670           impl.mController->SetPlaceholderProperty(*map);
 671         }
 672         break;
 673       }
 674       case Toolkit::TextField::Property::ELLIPSIS:
 675       {
 676         const bool ellipsis = value.Get<bool>();
 677         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ELLIPSIS %d\n", impl.mController.Get(), ellipsis);
 678
 679         impl.mController->SetTextElideEnabled(ellipsis);
 680         break;
 681       }
 682       case Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION:
 683       {
 684         const bool shiftSelection = value.Get<bool>();
 685         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_SHIFT_SELECTION %d\n", impl.mController.Get(), shiftSelection);
 686
 687         impl.mController->SetShiftSelectionEnabled(shiftSelection);
 688         break;
 689       }
 690       case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE:
 691       {
 692         const bool grabHandleEnabled = value.Get<bool>();
 693         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_GRAB_HANDLE %d\n", impl.mController.Get(), grabHandleEnabled);
 694
 695         impl.mController->SetGrabHandleEnabled(grabHandleEnabled);
 696         break;
 697       }
 698       case Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
 699       {
 700         impl.mController->SetMatchLayoutDirection(value.Get<bool>() ? DevelText::MatchLayoutDirection::LOCALE : DevelText::MatchLayoutDirection::CONTENTS);
 701         break;
 702       }
 703       case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP:
 704       {
 705         const bool grabHandlePopupEnabled = value.Get<bool>();
 706         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_GRAB_HANDLE_POPUP %d\n", impl.mController.Get(), grabHandlePopupEnabled);
 707
 708         impl.mController->SetGrabHandlePopupEnabled(grabHandlePopupEnabled);
 709         break;
 710       }
 711       case Toolkit::DevelTextField::Property::BACKGROUND:
 712       {
 713         const Vector4 backgroundColor = value.Get<Vector4>();
 714         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);
 715
 716         impl.mController->SetBackgroundEnabled(true);
 717         impl.mController->SetBackgroundColor(backgroundColor);
 718         break;
 719       }
 720       case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
 721       {
 722         uint32_t start = static_cast<uint32_t>(value.Get<int>());
 723         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_START %d\n", impl.mController.Get(), start);
 724         impl.SetTextSelectionRange(&start, nullptr);
 725         break;
 726       }
 727       case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
 728       {
 729         uint32_t end = static_cast<uint32_t>(value.Get<int>());
 730         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_END %d\n", impl.mController.Get(), end);
 731         impl.SetTextSelectionRange(nullptr, &end);
 732         break;
 733       }
 734       case Toolkit::DevelTextField::Property::ENABLE_EDITING:
 735       {
 736         const bool editable = value.Get<bool>();
 737         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p ENABLE_EDITING %d\n", impl.mController.Get(), editable);
 738         impl.SetEditable(editable);
 739         break;
 740       }
 741       case Toolkit::DevelTextField::Property::FONT_SIZE_SCALE:
 742       {
 743         const float scale = value.Get<float>();
 744         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p FONT_SIZE_SCALE %f\n", impl.mController.Get(), scale);
 745
 746         if(!Equals(impl.mController->GetFontSizeScale(), scale))
 747         {
 748           impl.mController->SetFontSizeScale(scale);
 749         }
 750         break;
 751       }
 752       case Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION:
 753       {
 754         uint32_t position = static_cast<uint32_t>(value.Get<int>());
 755         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p PRIMARY_CURSOR_POSITION %d\n", impl.mController.Get(), position);
 756         if(impl.mController->SetPrimaryCursorPosition(position, impl.HasKeyInputFocus()))
 757         {
 758           impl.SetKeyInputFocus();
 759         }
 760         break;
 761       }
 762       case Toolkit::DevelTextField::Property::GRAB_HANDLE_COLOR:
 763       {
 764         const Vector4 color = value.Get<Vector4>();
 765         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p GRAB_HANDLE_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
 766
 767         impl.mDecorator->SetHandleColor(color);
 768         impl.RequestTextRelayout();
 769         break;
 770       }
 771       case Toolkit::DevelTextField::Property::INPUT_FILTER:
 772       {
 773         const Property::Map* map = value.GetMap();
 774         if(map)
 775         {
 776           impl.mController->SetInputFilterOption(*map);
 777         }
 778         break;
 779       }
 780       case Toolkit::DevelTextField::Property::ELLIPSIS_POSITION:
 781       {
 782         DevelText::EllipsisPosition::Type ellipsisPositionType(static_cast<DevelText::EllipsisPosition::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
 783         if(GetEllipsisPositionTypeEnumeration(value, ellipsisPositionType))
 784         {
 785           DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p EllipsisPosition::Type %d\n", impl.mController.Get(), ellipsisPositionType);
 786           impl.mController->SetEllipsisPosition(ellipsisPositionType);
 787         }
 788         break;
 789       }
 790     } // switch
 791   }   // textfield
 792 }
 793
 794 Property::Value TextField::GetProperty(BaseObject* object, Property::Index index)
 795 {
 796   Property::Value value;
 797
 798   Toolkit::TextField textField = Toolkit::TextField::DownCast(Dali::BaseHandle(object));
 799
 800   if(textField)
 801   {
 802     TextField& impl(GetImpl(textField));
 803     DALI_ASSERT_DEBUG(impl.mController && "No text contoller");
 804     DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
 805
 806     switch(index)
 807     {
 808       case Toolkit::DevelTextField::Property::RENDERING_BACKEND:
 809       {
 810         value = impl.mRenderingBackend;
 811         break;
 812       }
 813       case Toolkit::TextField::Property::TEXT:
 814       {
 815         std::string text;
 816         impl.mController->GetText(text);
 817         DALI_LOG_INFO(gLogFilter, Debug::General, "TextField %p returning text: %s\n", impl.mController.Get(), text.c_str());
 818         value = text;
 819         break;
 820       }
 821       case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
 822       {
 823         std::string text;
 824         impl.mController->GetPlaceholderText(Controller::PLACEHOLDER_TYPE_INACTIVE, text);
 825         value = text;
 826         break;
 827       }
 828       case Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED:
 829       {
 830         std::string text;
 831         impl.mController->GetPlaceholderText(Controller::PLACEHOLDER_TYPE_ACTIVE, text);
 832         value = text;
 833         break;
 834       }
 835       case Toolkit::TextField::Property::FONT_FAMILY:
 836       {
 837         value = impl.mController->GetDefaultFontFamily();
 838         break;
 839       }
 840       case Toolkit::TextField::Property::FONT_STYLE:
 841       {
 842         GetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
 843         break;
 844       }
 845       case Toolkit::TextField::Property::POINT_SIZE:
 846       {
 847         value = impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE);
 848         break;
 849       }
 850       case Toolkit::TextField::Property::MAX_LENGTH:
 851       {
 852         value = impl.mController->GetMaximumNumberOfCharacters();
 853         break;
 854       }
 855       case Toolkit::TextField::Property::EXCEED_POLICY:
 856       {
 857         value = impl.mExceedPolicy;
 858         break;
 859       }
 860       case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
 861       {
 862         const char* name = Text::GetHorizontalAlignmentString(impl.mController->GetHorizontalAlignment());
 863
 864         if(name)
 865         {
 866           value = std::string(name);
 867         }
 868         break;
 869       }
 870       case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
 871       {
 872         const char* name = Text::GetVerticalAlignmentString(impl.mController->GetVerticalAlignment());
 873
 874         if(name)
 875         {
 876           value = std::string(name);
 877         }
 878         break;
 879       }
 880       case Toolkit::TextField::Property::TEXT_COLOR:
 881       {
 882         value = impl.mController->GetDefaultColor();
 883         break;
 884       }
 885       case Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR:
 886       {
 887         value = impl.mController->GetPlaceholderTextColor();
 888         break;
 889       }
 890       case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
 891       {
 892         value = impl.mDecorator->GetColor(PRIMARY_CURSOR);
 893         break;
 894       }
 895       case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
 896       {
 897         value = impl.mDecorator->GetColor(SECONDARY_CURSOR);
 898         break;
 899       }
 900       case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
 901       {
 902         value = impl.mController->GetEnableCursorBlink();
 903         break;
 904       }
 905       case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
 906       {
 907         value = impl.mDecorator->GetCursorBlinkInterval();
 908         break;
 909       }
 910       case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
 911       {
 912         value = impl.mDecorator->GetCursorBlinkDuration();
 913         break;
 914       }
 915       case Toolkit::TextField::Property::CURSOR_WIDTH:
 916       {
 917         value = impl.mDecorator->GetCursorWidth();
 918         break;
 919       }
 920       case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
 921       {
 922         value = impl.mDecorator->GetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_RELEASED);
 923         break;
 924       }
 925       case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
 926       {
 927         value = impl.mDecorator->GetHandleImage(GRAB_HANDLE, HANDLE_IMAGE_PRESSED);
 928         break;
 929       }
 930       case Toolkit::TextField::Property::SCROLL_THRESHOLD:
 931       {
 932         value = impl.mDecorator->GetScrollThreshold();
 933         break;
 934       }
 935       case Toolkit::TextField::Property::SCROLL_SPEED:
 936       {
 937         value = impl.mDecorator->GetScrollSpeed();
 938         break;
 939       }
 940       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
 941       {
 942         impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED);
 943         break;
 944       }
 945       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 946       {
 947         impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED);
 948         break;
 949       }
 950       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 951       {
 952         impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED);
 953         break;
 954       }
 955       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 956       {
 957         impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED);
 958         break;
 959       }
 960       case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 961       {
 962         impl.GetHandleImagePropertyValue(value, LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED);
 963         break;
 964       }
 965       case Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 966       {
 967         impl.GetHandleImagePropertyValue(value, RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED);
 968         break;
 969       }
 970       case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
 971       {
 972         value = impl.mDecorator->GetHighlightColor();
 973         break;
 974       }
 975       case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
 976       {
 977         Rect<int> boundingBox;
 978         impl.mDecorator->GetBoundingBox(boundingBox);
 979         value = boundingBox;
 980         break;
 981       }
 982       case Toolkit::TextField::Property::INPUT_METHOD_SETTINGS:
 983       {
 984         Property::Map map;
 985         impl.mInputMethodOptions.RetrieveProperty(map);
 986         value = map;
 987         break;
 988       }
 989       case Toolkit::TextField::Property::INPUT_COLOR:
 990       {
 991         value = impl.mController->GetInputColor();
 992         break;
 993       }
 994       case Toolkit::TextField::Property::ENABLE_MARKUP:
 995       {
 996         value = impl.mController->IsMarkupProcessorEnabled();
 997         break;
 998       }
 999       case Toolkit::TextField::Property::INPUT_FONT_FAMILY:
1000       {
1001         value = impl.mController->GetInputFontFamily();
1002         break;
1003       }
1004       case Toolkit::TextField::Property::INPUT_FONT_STYLE:
1005       {
1006         GetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
1007         break;
1008       }
1009       case Toolkit::TextField::Property::INPUT_POINT_SIZE:
1010       {
1011         value = impl.mController->GetInputFontPointSize();
1012         break;
1013       }
1014       case Toolkit::TextField::Property::UNDERLINE:
1015       {
1016         GetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
1017         break;
1018       }
1019       case Toolkit::TextField::Property::INPUT_UNDERLINE:
1020       {
1021         GetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
1022         break;
1023       }
1024       case Toolkit::TextField::Property::SHADOW:
1025       {
1026         GetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
1027         break;
1028       }
1029       case Toolkit::TextField::Property::INPUT_SHADOW:
1030       {
1031         GetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
1032         break;
1033       }
1034       case Toolkit::TextField::Property::EMBOSS:
1035       {
1036         GetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
1037         break;
1038       }
1039       case Toolkit::TextField::Property::INPUT_EMBOSS:
1040       {
1041         GetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
1042         break;
1043       }
1044       case Toolkit::TextField::Property::OUTLINE:
1045       {
1046         GetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
1047         break;
1048       }
1049       case Toolkit::TextField::Property::INPUT_OUTLINE:
1050       {
1051         GetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
1052         break;
1053       }
1054       case Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS:
1055       {
1056         Property::Map map;
1057         impl.mController->GetHiddenInputOption(map);
1058         value = map;
1059         break;
1060       }
1061       case Toolkit::TextField::Property::PIXEL_SIZE:
1062       {
1063         value = impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE);
1064         break;
1065       }
1066       case Toolkit::TextField::Property::ENABLE_SELECTION:
1067       {
1068         value = impl.mController->IsSelectionEnabled();
1069         break;
1070       }
1071       case Toolkit::TextField::Property::PLACEHOLDER:
1072       {
1073         Property::Map map;
1074         impl.mController->GetPlaceholderProperty(map);
1075         value = map;
1076         break;
1077       }
1078       case Toolkit::TextField::Property::ELLIPSIS:
1079       {
1080         value = impl.mController->IsTextElideEnabled();
1081         break;
1082       }
1083       case Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION:
1084       {
1085         value = impl.mController->IsShiftSelectionEnabled();
1086         break;
1087       }
1088       case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE:
1089       {
1090         value = impl.mController->IsGrabHandleEnabled();
1091         break;
1092       }
1093       case Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
1094       {
1095         value = impl.mController->GetMatchLayoutDirection() != DevelText::MatchLayoutDirection::CONTENTS;
1096         break;
1097       }
1098       case Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP:
1099       {
1100         value = impl.mController->IsGrabHandlePopupEnabled();
1101         break;
1102       }
1103       case Toolkit::DevelTextField::Property::BACKGROUND:
1104       {
1105         value = impl.mController->GetBackgroundColor();
1106         break;
1107       }
1108       case Toolkit::DevelTextField::Property::SELECTED_TEXT:
1109       {
1110         value = impl.mController->GetSelectedText();
1111         break;
1112       }
1113       case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
1114       {
1115         Uint32Pair range = impl.GetTextSelectionRange();
1116         value            = static_cast<int>(range.first);
1117         break;
1118       }
1119       case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
1120       {
1121         Uint32Pair range = impl.GetTextSelectionRange();
1122         value            = static_cast<int>(range.second);
1123         break;
1124       }
1125       case Toolkit::DevelTextField::Property::ENABLE_EDITING:
1126       {
1127         value = impl.IsEditable();
1128         break;
1129       }
1130       case Toolkit::DevelTextField::Property::FONT_SIZE_SCALE:
1131       {
1132         value = impl.mController->GetFontSizeScale();
1133         break;
1134       }
1135       case Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION:
1136       {
1137         value = static_cast<int>(impl.mController->GetPrimaryCursorPosition());
1138         break;
1139       }
1140       case Toolkit::DevelTextField::Property::GRAB_HANDLE_COLOR:
1141       {
1142         value = impl.mDecorator->GetHandleColor();
1143         break;
1144       }
1145       case Toolkit::DevelTextField::Property::INPUT_FILTER:
1146       {
1147         Property::Map map;
1148         impl.mController->GetInputFilterOption(map);
1149         value = map;
1150         break;
1151       }
1152       case Toolkit::DevelTextField::Property::ELLIPSIS_POSITION:
1153       {
1154         value = impl.mController->GetEllipsisPosition();
1155         break;
1156       }
1157     } //switch
1158   }
1159
1160   return value;
1161 }
1162
1163 void TextField::SelectWholeText()
1164 {
1165   if(mController && mController->IsShowingRealText())
1166   {
1167     mController->SelectWholeText();
1168     SetKeyInputFocus();
1169   }
1170 }
1171
1172 void TextField::SelectNone()
1173 {
1174   if(mController && mController->IsShowingRealText())
1175   {
1176     mController->SelectNone();
1177   }
1178 }
1179
1180 void TextField::SelectText(const uint32_t start, const uint32_t end)
1181 {
1182   if(mController && mController->IsShowingRealText())
1183   {
1184     mController->SelectText(start, end);
1185     SetKeyInputFocus();
1186   }
1187 }
1188
1189 string TextField::GetSelectedText() const
1190 {
1191   string selectedText = "";
1192   if(mController && mController->IsShowingRealText())
1193   {
1194     selectedText = mController->GetSelectedText();
1195   }
1196   return selectedText;
1197 }
1198
1199 void TextField::SetTextSelectionRange(const uint32_t* start, const uint32_t* end)
1200 {
1201   if(mController && mController->IsShowingRealText())
1202   {
1203     mController->SetTextSelectionRange(start, end);
1204     SetKeyInputFocus();
1205   }
1206 }
1207
1208 Uint32Pair TextField::GetTextSelectionRange() const
1209 {
1210   Uint32Pair range;
1211   if(mController && mController->IsShowingRealText())
1212   {
1213     range = mController->GetTextSelectionRange();
1214   }
1215   return range;
1216 }
1217
1218 InputMethodContext TextField::GetInputMethodContext()
1219 {
1220   return mInputMethodContext;
1221 }
1222
1223 bool TextField::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
1224 {
1225   Dali::BaseHandle handle(object);
1226
1227   bool               connected(true);
1228   Toolkit::TextField field = Toolkit::TextField::DownCast(handle);
1229
1230   if(0 == strcmp(signalName.c_str(), SIGNAL_TEXT_CHANGED))
1231   {
1232     field.TextChangedSignal().Connect(tracker, functor);
1233   }
1234   else if(0 == strcmp(signalName.c_str(), SIGNAL_MAX_LENGTH_REACHED))
1235   {
1236     field.MaxLengthReachedSignal().Connect(tracker, functor);
1237   }
1238   else if(0 == strcmp(signalName.c_str(), SIGNAL_INPUT_STYLE_CHANGED))
1239   {
1240     field.InputStyleChangedSignal().Connect(tracker, functor);
1241   }
1242   else if(0 == strcmp(signalName.c_str(), SIGNAL_ANCHOR_CLICKED))
1243   {
1244     if(field)
1245     {
1246       Internal::TextField& fieldImpl(GetImpl(field));
1247       fieldImpl.AnchorClickedSignal().Connect(tracker, functor);
1248     }
1249   }
1250   else if(0 == strcmp(signalName.c_str(), SIGNAL_CURSOR_POSITION_CHANGED))
1251   {
1252     if(field)
1253     {
1254       Internal::TextField& fieldImpl(GetImpl(field));
1255       fieldImpl.CursorPositionChangedSignal().Connect(tracker, functor);
1256     }
1257   }
1258   else if(0 == strcmp(signalName.c_str(), SIGNAL_INPUT_FILTERED))
1259   {
1260     if(field)
1261     {
1262       Internal::TextField& fieldImpl(GetImpl(field));
1263       fieldImpl.InputFilteredSignal().Connect(tracker, functor);
1264     }
1265   }
1266   else
1267   {
1268     // signalName does not match any signal
1269     connected = false;
1270   }
1271
1272   return connected;
1273 }
1274
1275 Toolkit::TextField::TextChangedSignalType& TextField::TextChangedSignal()
1276 {
1277   return mTextChangedSignal;
1278 }
1279
1280 Toolkit::TextField::MaxLengthReachedSignalType& TextField::MaxLengthReachedSignal()
1281 {
1282   return mMaxLengthReachedSignal;
1283 }
1284
1285 Toolkit::TextField::InputStyleChangedSignalType& TextField::InputStyleChangedSignal()
1286 {
1287   return mInputStyleChangedSignal;
1288 }
1289
1290 DevelTextField::AnchorClickedSignalType& TextField::AnchorClickedSignal()
1291 {
1292   return mAnchorClickedSignal;
1293 }
1294
1295 DevelTextField::CursorPositionChangedSignalType& TextField::CursorPositionChangedSignal()
1296 {
1297   return mCursorPositionChangedSignal;
1298 }
1299
1300 DevelTextField::InputFilteredSignalType& TextField::InputFilteredSignal()
1301 {
1302   return mInputFilteredSignal;
1303 }
1304
1305 void TextField::OnInitialize()
1306 {
1307   Actor self = Self();
1308
1309   mController = Text::Controller::New(this, this, this, this);
1310
1311   // When using the vector-based rendering, the size of the GLyphs are different
1312   TextAbstraction::GlyphType glyphType = (DevelText::RENDERING_VECTOR_BASED == mRenderingBackend) ? TextAbstraction::VECTOR_GLYPH : TextAbstraction::BITMAP_GLYPH;
1313   mController->SetGlyphType(glyphType);
1314
1315   mDecorator = Text::Decorator::New(*mController,
1316                                     *mController);
1317
1318   mInputMethodContext = InputMethodContext::New(self);
1319
1320   mController->GetLayoutEngine().SetLayout(Layout::Engine::SINGLE_LINE_BOX);
1321
1322   // Enables the text input.
1323   mController->EnableTextInput(mDecorator, mInputMethodContext);
1324
1325   // Enables the horizontal scrolling after the text input has been enabled.
1326   mController->SetHorizontalScrollEnabled(true);
1327
1328   // Disables the vertical scrolling.
1329   mController->SetVerticalScrollEnabled(false);
1330
1331   // Disable the smooth handle panning.
1332   mController->SetSmoothHandlePanEnabled(false);
1333
1334   mController->SetNoTextDoubleTapAction(Controller::NoTextTap::HIGHLIGHT);
1335   mController->SetNoTextLongPressAction(Controller::NoTextTap::HIGHLIGHT);
1336
1337   // Sets layoutDirection value
1338   Dali::Stage                 stage           = Dali::Stage::GetCurrent();
1339   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(stage.GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
1340   mController->SetLayoutDirection(layoutDirection);
1341
1342   self.LayoutDirectionChangedSignal().Connect(this, &TextField::OnLayoutDirectionChanged);
1343
1344   // Forward input events to controller
1345   EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS));
1346   GetTapGestureDetector().SetMaximumTapsRequired(2);
1347
1348   self.TouchedSignal().Connect(this, &TextField::OnTouched);
1349
1350   // Set BoundingBox to stage size if not already set.
1351   Rect<int> boundingBox;
1352   mDecorator->GetBoundingBox(boundingBox);
1353
1354   if(boundingBox.IsEmpty())
1355   {
1356     Vector2 stageSize = Dali::Stage::GetCurrent().GetSize();
1357     mDecorator->SetBoundingBox(Rect<int>(0.0f, 0.0f, stageSize.width, stageSize.height));
1358   }
1359
1360   // Flip vertically the 'left' selection handle
1361   mDecorator->FlipHandleVertically(LEFT_SELECTION_HANDLE, true);
1362
1363   // Fill-parent area by default
1364   self.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH);
1365   self.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT);
1366   self.OnSceneSignal().Connect(this, &TextField::OnSceneConnect);
1367
1368   //Enable highightability
1369   self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
1370
1371   DevelControl::SetInputMethodContext(*this, mInputMethodContext);
1372
1373   if(Dali::Toolkit::TextField::EXCEED_POLICY_CLIP == mExceedPolicy)
1374   {
1375     EnableClipping();
1376   }
1377
1378   DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) {
1379     return std::unique_ptr<Dali::Accessibility::Accessible>(
1380       new AccessibleImpl(actor, Dali::Accessibility::Role::ENTRY));
1381   });
1382 }
1383
1384 void TextField::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change)
1385 {
1386   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnStyleChange\n");
1387
1388   switch(change)
1389   {
1390     case StyleChange::DEFAULT_FONT_CHANGE:
1391     {
1392       DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnStyleChange DEFAULT_FONT_CHANGE\n");
1393       const std::string& newFont = GetImpl(styleManager).GetDefaultFontFamily();
1394       // Property system did not set the font so should update it.
1395       mController->UpdateAfterFontChange(newFont);
1396       RelayoutRequest();
1397       break;
1398     }
1399
1400     case StyleChange::DEFAULT_FONT_SIZE_CHANGE:
1401     {
1402       GetImpl(styleManager).ApplyThemeStyle(Toolkit::Control(GetOwner()));
1403       RelayoutRequest();
1404       break;
1405     }
1406     case StyleChange::THEME_CHANGE:
1407     {
1408       // Nothing to do, let control base class handle this
1409       break;
1410     }
1411   }
1412
1413   // Up call to Control
1414   Control::OnStyleChange(styleManager, change);
1415 }
1416
1417 Vector3 TextField::GetNaturalSize()
1418 {
1419   Extents padding;
1420   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1421
1422   Vector3 naturalSize = mController->GetNaturalSize();
1423   naturalSize.width += (padding.start + padding.end);
1424   naturalSize.height += (padding.top + padding.bottom);
1425
1426   return naturalSize;
1427 }
1428
1429 float TextField::GetHeightForWidth(float width)
1430 {
1431   Extents padding;
1432   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1433   return mController->GetHeightForWidth(width) + padding.top + padding.bottom;
1434 }
1435
1436 void TextField::ResizeActor(Actor& actor, const Vector2& size)
1437 {
1438   if(actor.GetProperty<Vector3>(Dali::Actor::Property::SIZE).GetVectorXY() != size)
1439   {
1440     actor.SetProperty(Actor::Property::SIZE, size);
1441   }
1442 }
1443
1444 void TextField::OnRelayout(const Vector2& size, RelayoutContainer& container)
1445 {
1446   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField OnRelayout\n");
1447
1448   Actor self = Self();
1449
1450   Extents padding;
1451   padding = self.GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1452
1453   Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom));
1454
1455   // Support Right-To-Left of padding
1456   Dali::LayoutDirection::Type layoutDirection = mController->GetLayoutDirection(self);
1457
1458   if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
1459   {
1460     std::swap(padding.start, padding.end);
1461   }
1462
1463   if(mStencil)
1464   {
1465     mStencil.SetProperty(Actor::Property::POSITION, Vector2(padding.start, padding.top));
1466     ResizeActor(mStencil, contentSize);
1467   }
1468   if(mActiveLayer)
1469   {
1470     mActiveLayer.SetProperty(Actor::Property::POSITION, Vector2(padding.start, padding.top));
1471     ResizeActor(mActiveLayer, contentSize);
1472   }
1473
1474   // If there is text changed, callback is called.
1475   if(mTextChanged)
1476   {
1477     EmitTextChangedSignal();
1478   }
1479
1480   const Text::Controller::UpdateTextType updateTextType = mController->Relayout(contentSize, layoutDirection);
1481
1482   if((Text::Controller::NONE_UPDATED != updateTextType) ||
1483      !mRenderer)
1484   {
1485     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnRelayout %p Displaying new contents\n", mController.Get());
1486
1487     if(mDecorator &&
1488        (Text::Controller::NONE_UPDATED != (Text::Controller::DECORATOR_UPDATED & updateTextType)))
1489     {
1490       mDecorator->Relayout(contentSize);
1491     }
1492
1493     if(!mRenderer)
1494     {
1495       mRenderer = Backend::Get().NewRenderer(mRenderingBackend);
1496     }
1497
1498     RenderText(updateTextType);
1499   }
1500
1501   if(mCursorPositionChanged)
1502   {
1503     EmitCursorPositionChangedSignal();
1504   }
1505
1506   // The text-field emits signals when the input style changes. These changes of style are
1507   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1508   // can't be emitted during the size negotiation as the callbacks may update the UI.
1509   // The text-field adds an idle callback to the adaptor to emit the signals after the size negotiation.
1510   if(!mController->IsInputStyleChangedSignalsQueueEmpty())
1511   {
1512     if(Adaptor::IsAvailable())
1513     {
1514       Adaptor& adaptor = Adaptor::Get();
1515
1516       if(NULL == mIdleCallback)
1517       {
1518         // @note: The callback manager takes the ownership of the callback object.
1519         mIdleCallback = MakeCallback(this, &TextField::OnIdleSignal);
1520         adaptor.AddIdle(mIdleCallback, false);
1521       }
1522     }
1523   }
1524 }
1525
1526 Text::ControllerPtr TextField::GetTextController()
1527 {
1528   return mController;
1529 }
1530
1531 void TextField::RenderText(Text::Controller::UpdateTextType updateTextType)
1532 {
1533   Actor renderableActor;
1534
1535   if(Text::Controller::NONE_UPDATED != (Text::Controller::MODEL_UPDATED & updateTextType))
1536   {
1537     if(mRenderer)
1538     {
1539       Dali::Toolkit::TextField handle = Dali::Toolkit::TextField(GetOwner());
1540
1541       renderableActor = mRenderer->Render(mController->GetView(),
1542                                           handle,
1543                                           Property::INVALID_INDEX, // Animatable property not supported
1544                                           mAlignmentOffset,
1545                                           DepthIndex::CONTENT);
1546     }
1547
1548     if(renderableActor != mRenderableActor)
1549     {
1550       UnparentAndReset(mBackgroundActor);
1551       UnparentAndReset(mRenderableActor);
1552       mRenderableActor = renderableActor;
1553
1554       if(mRenderableActor)
1555       {
1556         mBackgroundActor = mController->CreateBackgroundActor();
1557       }
1558     }
1559   }
1560
1561   if(mRenderableActor)
1562   {
1563     const Vector2& scrollOffset = mController->GetTextModel()->GetScrollPosition();
1564
1565     float renderableActorPositionX, renderableActorPositionY;
1566
1567     if(mStencil)
1568     {
1569       renderableActorPositionX = scrollOffset.x + mAlignmentOffset;
1570       renderableActorPositionY = scrollOffset.y;
1571     }
1572     else
1573     {
1574       Extents padding;
1575       padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1576
1577       // Support Right-To-Left of padding
1578       Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
1579       if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
1580       {
1581         std::swap(padding.start, padding.end);
1582       }
1583
1584       renderableActorPositionX = scrollOffset.x + mAlignmentOffset + padding.start;
1585       renderableActorPositionY = scrollOffset.y + padding.top;
1586     }
1587
1588     mRenderableActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY));
1589
1590     // Make sure the actors are parented correctly with/without clipping
1591     Actor self = mStencil ? mStencil : Self();
1592
1593     Actor highlightActor;
1594
1595     for(std::vector<Actor>::iterator it    = mClippingDecorationActors.begin(),
1596                                      endIt = mClippingDecorationActors.end();
1597         it != endIt;
1598         ++it)
1599     {
1600       self.Add(*it);
1601       it->LowerToBottom();
1602
1603       if(it->GetProperty<std::string>(Dali::Actor::Property::NAME) == "HighlightActor")
1604       {
1605         highlightActor = *it;
1606       }
1607     }
1608     mClippingDecorationActors.clear();
1609
1610     self.Add(mRenderableActor);
1611
1612     if(mBackgroundActor)
1613     {
1614       if(mDecorator && mDecorator->IsHighlightVisible())
1615       {
1616         self.Add(mBackgroundActor);
1617         mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY)); // In text field's coords.
1618         mBackgroundActor.LowerBelow(highlightActor);
1619       }
1620       else
1621       {
1622         mRenderableActor.Add(mBackgroundActor);
1623         mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f)); // In renderable actor's coords.
1624         mBackgroundActor.LowerToBottom();
1625       }
1626     }
1627   }
1628 }
1629
1630 void TextField::OnKeyInputFocusGained()
1631 {
1632   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnKeyInputFocusGained %p\n", mController.Get());
1633   if(mInputMethodContext && IsEditable())
1634   {
1635     // All input panel properties, such as layout, return key type, and input hint, should be set before input panel activates (or shows).
1636     mInputMethodContext.ApplyOptions(mInputMethodOptions);
1637     mInputMethodContext.NotifyTextInputMultiLine(false);
1638
1639     mInputMethodContext.StatusChangedSignal().Connect(this, &TextField::KeyboardStatusChanged);
1640
1641     mInputMethodContext.EventReceivedSignal().Connect(this, &TextField::OnInputMethodContextEvent);
1642
1643     // Notify that the text editing start.
1644     mInputMethodContext.Activate();
1645
1646     // When window gain lost focus, the inputMethodContext is deactivated. Thus when window gain focus again, the inputMethodContext must be activated.
1647     mInputMethodContext.SetRestoreAfterFocusLost(true);
1648   }
1649   ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
1650
1651   if(notifier)
1652   {
1653     notifier.ContentSelectedSignal().Connect(this, &TextField::OnClipboardTextSelected);
1654   }
1655
1656   mController->KeyboardFocusGainEvent(); // Called in the case of no virtual keyboard to trigger this event
1657
1658   EmitKeyInputFocusSignal(true); // Calls back into the Control hence done last.
1659 }
1660
1661 void TextField::OnKeyInputFocusLost()
1662 {
1663   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField:OnKeyInputFocusLost %p\n", mController.Get());
1664   if(mInputMethodContext)
1665   {
1666     mInputMethodContext.StatusChangedSignal().Disconnect(this, &TextField::KeyboardStatusChanged);
1667     // The text editing is finished. Therefore the inputMethodContext don't have restore activation.
1668     mInputMethodContext.SetRestoreAfterFocusLost(false);
1669
1670     // Notify that the text editing finish.
1671     mInputMethodContext.Deactivate();
1672
1673     mInputMethodContext.EventReceivedSignal().Disconnect(this, &TextField::OnInputMethodContextEvent);
1674   }
1675   ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
1676
1677   if(notifier)
1678   {
1679     notifier.ContentSelectedSignal().Disconnect(this, &TextField::OnClipboardTextSelected);
1680   }
1681
1682   mController->KeyboardFocusLostEvent();
1683
1684   EmitKeyInputFocusSignal(false); // Calls back into the Control hence done last.
1685 }
1686
1687 bool TextField::OnAccessibilityActivated()
1688 {
1689   SetKeyInputFocus();
1690   return true;
1691 }
1692
1693 void TextField::OnTap(const TapGesture& gesture)
1694 {
1695   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnTap %p\n", mController.Get());
1696   if(mInputMethodContext && IsEditable())
1697   {
1698     mInputMethodContext.Activate();
1699   }
1700   // Deliver the tap before the focus event to controller; this allows us to detect when focus is gained due to tap-gestures
1701   Extents padding;
1702   padding                   = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1703   const Vector2& localPoint = gesture.GetLocalPoint();
1704   mController->TapEvent(gesture.GetNumberOfTaps(), localPoint.x - padding.start, localPoint.y - padding.top);
1705   mController->AnchorEvent(localPoint.x - padding.start, localPoint.y - padding.top);
1706
1707   SetKeyInputFocus();
1708 }
1709
1710 void TextField::OnPan(const PanGesture& gesture)
1711 {
1712   mController->PanEvent(gesture.GetState(), gesture.GetDisplacement());
1713 }
1714
1715 void TextField::OnLongPress(const LongPressGesture& gesture)
1716 {
1717   if(mInputMethodContext && IsEditable())
1718   {
1719     mInputMethodContext.Activate();
1720   }
1721   Extents padding;
1722   padding                   = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
1723   const Vector2& localPoint = gesture.GetLocalPoint();
1724   mController->LongPressEvent(gesture.GetState(), localPoint.x - padding.start, localPoint.y - padding.top);
1725
1726   SetKeyInputFocus();
1727 }
1728
1729 bool TextField::OnKeyEvent(const KeyEvent& event)
1730 {
1731   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnKeyEvent %p keyCode %d\n", mController.Get(), event.GetKeyCode());
1732
1733   if(Dali::DALI_KEY_ESCAPE == event.GetKeyCode() && mController->ShouldClearFocusOnEscape())
1734   {
1735     // Make sure ClearKeyInputFocus when only key is up
1736     if(event.GetState() == KeyEvent::UP)
1737     {
1738       ClearKeyInputFocus();
1739     }
1740
1741     return true;
1742   }
1743   else if(Dali::DevelKey::DALI_KEY_RETURN == event.GetKeyCode())
1744   {
1745     // Do nothing when enter is comming.
1746     return false;
1747   }
1748
1749   return mController->KeyEvent(event);
1750 }
1751
1752 void TextField::RequestTextRelayout()
1753 {
1754   RelayoutRequest();
1755 }
1756
1757 bool TextField::IsEditable() const
1758 {
1759   return mController->IsEditable();
1760 }
1761
1762 void TextField::SetEditable(bool editable)
1763 {
1764   mController->SetEditable(editable);
1765   if(mInputMethodContext && !editable)
1766   {
1767     mInputMethodContext.Deactivate();
1768   }
1769 }
1770
1771 void TextField::TextInserted(unsigned int position, unsigned int length, const std::string& content)
1772 {
1773   if(Accessibility::IsUp())
1774   {
1775     Control::Impl::GetAccessibilityObject(Self())->EmitTextInserted(position, length, content);
1776   }
1777 }
1778
1779 void TextField::TextDeleted(unsigned int position, unsigned int length, const std::string& content)
1780 {
1781   if(Accessibility::IsUp())
1782   {
1783     Control::Impl::GetAccessibilityObject(Self())->EmitTextDeleted(position, length, content);
1784   }
1785 }
1786
1787 void TextField::CursorPositionChanged(unsigned int oldPosition, unsigned int newPosition)
1788 {
1789   if(Accessibility::IsUp())
1790   {
1791     Control::Impl::GetAccessibilityObject(Self())->EmitTextCursorMoved(newPosition);
1792   }
1793
1794   if((oldPosition != newPosition) && !mCursorPositionChanged)
1795   {
1796     mCursorPositionChanged = true;
1797     mOldPosition           = oldPosition;
1798   }
1799 }
1800
1801 void TextField::TextChanged(bool immediate)
1802 {
1803   if(immediate) // Emits TextChangedSignal immediately
1804   {
1805     EmitTextChangedSignal();
1806   }
1807   else
1808   {
1809     mTextChanged = true;
1810   }
1811 }
1812
1813 void TextField::EmitTextChangedSignal()
1814 {
1815   Dali::Toolkit::TextField handle(GetOwner());
1816   mTextChangedSignal.Emit(handle);
1817   mTextChanged = false;
1818 }
1819
1820 void TextField::MaxLengthReached()
1821 {
1822   Dali::Toolkit::TextField handle(GetOwner());
1823   mMaxLengthReachedSignal.Emit(handle);
1824 }
1825
1826 void TextField::InputStyleChanged(Text::InputStyle::Mask inputStyleMask)
1827 {
1828   Dali::Toolkit::TextField handle(GetOwner());
1829
1830   Toolkit::TextField::InputStyle::Mask fieldInputStyleMask = Toolkit::TextField::InputStyle::NONE;
1831
1832   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_COLOR))
1833   {
1834     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::COLOR);
1835   }
1836   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_FAMILY))
1837   {
1838     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_FAMILY);
1839   }
1840   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_POINT_SIZE))
1841   {
1842     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::POINT_SIZE);
1843   }
1844   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WEIGHT))
1845   {
1846     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
1847   }
1848   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_WIDTH))
1849   {
1850     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
1851   }
1852   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_FONT_SLANT))
1853   {
1854     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::FONT_STYLE);
1855   }
1856   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_UNDERLINE))
1857   {
1858     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::UNDERLINE);
1859   }
1860   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_SHADOW))
1861   {
1862     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::SHADOW);
1863   }
1864   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_EMBOSS))
1865   {
1866     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::EMBOSS);
1867   }
1868   if(InputStyle::NONE != static_cast<InputStyle::Mask>(inputStyleMask & InputStyle::INPUT_OUTLINE))
1869   {
1870     fieldInputStyleMask = static_cast<Toolkit::TextField::InputStyle::Mask>(fieldInputStyleMask | Toolkit::TextField::InputStyle::OUTLINE);
1871   }
1872
1873   mInputStyleChangedSignal.Emit(handle, fieldInputStyleMask);
1874 }
1875
1876 void TextField::AnchorClicked(const std::string& href)
1877 {
1878   Dali::Toolkit::TextField handle(GetOwner());
1879   mAnchorClickedSignal.Emit(handle, href.c_str(), href.length());
1880 }
1881
1882 void TextField::EmitCursorPositionChangedSignal()
1883 {
1884   Dali::Toolkit::TextField handle(GetOwner());
1885   mCursorPositionChangedSignal.Emit(handle, mOldPosition);
1886   mCursorPositionChanged = false;
1887 }
1888
1889 void TextField::InputFiltered(Toolkit::InputFilter::Property::Type type)
1890 {
1891   Dali::Toolkit::TextField handle(GetOwner());
1892   mInputFilteredSignal.Emit(handle, type);
1893 }
1894
1895 void TextField::AddDecoration(Actor& actor, bool needsClipping)
1896 {
1897   if(actor)
1898   {
1899     if(needsClipping)
1900     {
1901       mClippingDecorationActors.push_back(actor);
1902     }
1903     else
1904     {
1905       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1906       actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1907       Self().Add(actor);
1908       mActiveLayer = actor;
1909     }
1910   }
1911 }
1912
1913 void TextField::GetControlBackgroundColor(Vector4& color) const
1914 {
1915   Property::Value propValue = Self().GetProperty(Toolkit::Control::Property::BACKGROUND);
1916   Property::Map*  resultMap = propValue.GetMap();
1917
1918   Property::Value* colorValue = nullptr;
1919   if(resultMap && (colorValue = resultMap->Find(ColorVisual::Property::MIX_COLOR)))
1920   {
1921     colorValue->Get(color);
1922   }
1923 }
1924
1925 void TextField::OnSceneConnect(Dali::Actor actor)
1926 {
1927   if(mHasBeenStaged)
1928   {
1929     RenderText(static_cast<Text::Controller::UpdateTextType>(Text::Controller::MODEL_UPDATED | Text::Controller::DECORATOR_UPDATED));
1930   }
1931   else
1932   {
1933     mHasBeenStaged = true;
1934   }
1935 }
1936
1937 InputMethodContext::CallbackData TextField::OnInputMethodContextEvent(Dali::InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
1938 {
1939   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::OnInputMethodContextEvent %p eventName %d\n", mController.Get(), inputMethodContextEvent.eventName);
1940   return mController->OnInputMethodContextEvent(inputMethodContext, inputMethodContextEvent);
1941 }
1942
1943 void TextField::GetHandleImagePropertyValue(Property::Value& value, Text::HandleType handleType, Text::HandleImageType handleImageType)
1944 {
1945   if(mDecorator)
1946   {
1947     Property::Map map;
1948     map[IMAGE_MAP_FILENAME_STRING] = mDecorator->GetHandleImage(handleType, handleImageType);
1949     value                          = map;
1950   }
1951 }
1952
1953 void TextField::EnableClipping()
1954 {
1955   if(!mStencil)
1956   {
1957     // Creates an extra control to be used as stencil buffer.
1958     mStencil = Control::New();
1959     mStencil.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1960     mStencil.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1961
1962     // Creates a background visual. Even if the color is transparent it updates the stencil.
1963     mStencil.SetProperty(Toolkit::Control::Property::BACKGROUND,
1964                          Property::Map().Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR).Add(ColorVisual::Property::MIX_COLOR, Color::TRANSPARENT));
1965
1966     // Enable the clipping property.
1967     mStencil.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
1968     mStencil.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1969
1970     Self().Add(mStencil);
1971   }
1972 }
1973
1974 void TextField::OnClipboardTextSelected(ClipboardEventNotifier& clipboard)
1975 {
1976   mController->PasteClipboardItemEvent();
1977 }
1978
1979 void TextField::KeyboardStatusChanged(bool keyboardShown)
1980 {
1981   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextField::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown);
1982
1983   // Just hide the grab handle when keyboard is hidden.
1984   if(!keyboardShown)
1985   {
1986     mController->KeyboardFocusLostEvent();
1987   }
1988   else
1989   {
1990     mController->KeyboardFocusGainEvent(); // Initially called by OnKeyInputFocusGained
1991   }
1992 }
1993
1994 void TextField::OnSceneConnection(int depth)
1995 {
1996   // Sets the depth to the visuals inside the text's decorator.
1997   mDecorator->SetTextDepth(depth);
1998
1999   // The depth of the text renderer is set in the RenderText() called from OnRelayout().
2000
2001   // Call the Control::OnSceneConnection() to set the depth of the background.
2002   Control::OnSceneConnection(depth);
2003 }
2004
2005 bool TextField::OnTouched(Actor actor, const TouchEvent& touch)
2006 {
2007   return false;
2008 }
2009
2010 void TextField::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
2011 {
2012   mController->ChangedLayoutDirection();
2013 }
2014
2015 void TextField::OnIdleSignal()
2016 {
2017   // Emits the change of input style signals.
2018   mController->ProcessInputStyleChangedSignals();
2019
2020   // Set the pointer to null as the callback manager deletes the callback after execute it.
2021   mIdleCallback = NULL;
2022 }
2023
2024 TextField::TextField()
2025 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
2026   mIdleCallback(NULL),
2027   mAlignmentOffset(0.f),
2028   mRenderingBackend(DEFAULT_RENDERING_BACKEND),
2029   mExceedPolicy(Dali::Toolkit::TextField::EXCEED_POLICY_CLIP),
2030   mHasBeenStaged(false),
2031   mTextChanged(false),
2032   mCursorPositionChanged(false)
2033 {
2034 }
2035
2036 TextField::~TextField()
2037 {
2038   UnparentAndReset(mStencil);
2039
2040   if((NULL != mIdleCallback) && Adaptor::IsAvailable())
2041   {
2042     Adaptor::Get().RemoveIdle(mIdleCallback);
2043   }
2044 }
2045
2046 std::string TextField::AccessibleImpl::GetName()
2047 {
2048   auto self = Toolkit::TextField::DownCast(Self());
2049   return self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2050 }
2051
2052 std::string TextField::AccessibleImpl::GetText(size_t startOffset, size_t endOffset)
2053 {
2054   if(endOffset <= startOffset)
2055   {
2056     return {};
2057   }
2058
2059   auto self = Toolkit::TextField::DownCast(Self());
2060   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2061
2062   if(startOffset > text.size() || endOffset > text.size())
2063   {
2064     return {};
2065   }
2066
2067   return text.substr(startOffset, endOffset - startOffset);
2068 }
2069
2070 size_t TextField::AccessibleImpl::GetCharacterCount()
2071 {
2072   auto self = Toolkit::TextField::DownCast(Self());
2073   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2074
2075   return text.size();
2076 }
2077
2078 size_t TextField::AccessibleImpl::GetCursorOffset()
2079 {
2080   auto self = Toolkit::TextField::DownCast(Self());
2081   return Dali::Toolkit::GetImpl(self).GetTextController()->GetCursorPosition();
2082 }
2083
2084 bool TextField::AccessibleImpl::SetCursorOffset(size_t offset)
2085 {
2086   auto self = Toolkit::TextField::DownCast(Self());
2087   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2088   if(offset > text.size())
2089   {
2090     return false;
2091   }
2092
2093   auto& selfImpl = Dali::Toolkit::GetImpl(self);
2094   selfImpl.GetTextController()->ResetCursorPosition(offset);
2095   selfImpl.RequestTextRelayout();
2096
2097   return true;
2098 }
2099
2100 Dali::Accessibility::Range TextField::AccessibleImpl::GetTextAtOffset(
2101   size_t offset, Dali::Accessibility::TextBoundary boundary)
2102 {
2103   auto self     = Toolkit::TextField::DownCast(Self());
2104   auto text     = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2105   auto textSize = text.size();
2106
2107   auto range = Dali::Accessibility::Range{};
2108
2109   switch(boundary)
2110   {
2111     case Dali::Accessibility::TextBoundary::CHARACTER:
2112     {
2113       if(offset < textSize)
2114       {
2115         range.content     = text[offset];
2116         range.startOffset = offset;
2117         range.endOffset   = offset + 1;
2118       }
2119       break;
2120     }
2121     case Dali::Accessibility::TextBoundary::WORD:
2122     case Dali::Accessibility::TextBoundary::LINE:
2123     {
2124       auto textString = text.c_str();
2125       auto breaks     = std::vector<char>(textSize, 0);
2126
2127       if(boundary == Dali::Accessibility::TextBoundary::WORD)
2128       {
2129         Accessibility::Accessible::FindWordSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
2130       }
2131       else
2132       {
2133         Accessibility::Accessible::FindLineSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
2134       }
2135
2136       auto index   = 0u;
2137       auto counter = 0u;
2138       while(index < textSize && counter <= offset)
2139       {
2140         auto start = index;
2141         if(breaks[index])
2142         {
2143           while(breaks[index])
2144           {
2145             index++;
2146           }
2147           counter++;
2148         }
2149         else
2150         {
2151           if(boundary == Dali::Accessibility::TextBoundary::WORD)
2152           {
2153             index++;
2154           }
2155           if(boundary == Dali::Accessibility::TextBoundary::LINE)
2156           {
2157             counter++;
2158           }
2159         }
2160
2161         if((counter > 0) && ((counter - 1) == offset))
2162         {
2163           range.content     = text.substr(start, index - start + 1);
2164           range.startOffset = start;
2165           range.endOffset   = index + 1;
2166         }
2167
2168         if(boundary == Dali::Accessibility::TextBoundary::LINE)
2169         {
2170           index++;
2171         }
2172       }
2173       break;
2174     }
2175     case Dali::Accessibility::TextBoundary::SENTENCE:
2176     {
2177       /* not supported by default */
2178       break;
2179     }
2180     case Dali::Accessibility::TextBoundary::PARAGRAPH:
2181     {
2182       /* Paragraph is not supported by libunibreak library */
2183       break;
2184     }
2185     default:
2186       break;
2187   }
2188
2189   return range;
2190 }
2191
2192 Dali::Accessibility::Range TextField::AccessibleImpl::GetRangeOfSelection(size_t selectionIndex)
2193 {
2194   // Since DALi supports only one selection indexes higher than 0 are ignored
2195   if(selectionIndex > 0)
2196   {
2197     return {};
2198   }
2199
2200   auto        self       = Toolkit::TextField::DownCast(Self());
2201   auto        controller = Dali::Toolkit::GetImpl(self).GetTextController();
2202   std::string value{};
2203   controller->RetrieveSelection(value);
2204   auto indices = controller->GetSelectionIndexes();
2205
2206   return {static_cast<size_t>(indices.first), static_cast<size_t>(indices.second), value};
2207 }
2208
2209 bool TextField::AccessibleImpl::RemoveSelection(size_t selectionIndex)
2210 {
2211   // Since DALi supports only one selection indexes higher than 0 are ignored
2212   if(selectionIndex > 0)
2213   {
2214     return false;
2215   }
2216
2217   auto self = Toolkit::TextField::DownCast(Self());
2218   Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(0, 0);
2219   return true;
2220 }
2221
2222 bool TextField::AccessibleImpl::SetRangeOfSelection(size_t selectionIndex, size_t startOffset, size_t endOffset)
2223 {
2224   // Since DALi supports only one selection indexes higher than 0 are ignored
2225   if(selectionIndex > 0)
2226   {
2227     return false;
2228   }
2229
2230   auto self = Toolkit::TextField::DownCast(Self());
2231   Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(startOffset, endOffset);
2232   return true;
2233 }
2234
2235 bool TextField::AccessibleImpl::CopyText(size_t startPosition, size_t endPosition)
2236 {
2237   if(endPosition <= startPosition)
2238   {
2239     return false;
2240   }
2241
2242   auto self = Toolkit::TextField::DownCast(Self());
2243   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2244   Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
2245
2246   return true;
2247 }
2248
2249 bool TextField::AccessibleImpl::CutText(size_t startPosition, size_t endPosition)
2250 {
2251   if(endPosition <= startPosition)
2252   {
2253     return false;
2254   }
2255
2256   auto self = Toolkit::TextField::DownCast(Self());
2257   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2258   Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
2259
2260   self.SetProperty(Toolkit::TextField::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
2261
2262   return true;
2263 }
2264
2265 bool TextField::AccessibleImpl::DeleteText(size_t startPosition, size_t endPosition)
2266 {
2267   if(endPosition <= startPosition)
2268   {
2269     return false;
2270   }
2271
2272   auto self = Toolkit::TextField::DownCast(Self());
2273   auto text = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2274
2275   self.SetProperty(Toolkit::TextField::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
2276
2277   return true;
2278 }
2279
2280 Dali::Accessibility::States TextField::AccessibleImpl::CalculateStates()
2281 {
2282   using namespace Dali::Accessibility;
2283
2284   auto states = DevelControl::AccessibleImpl::CalculateStates();
2285
2286   states[State::EDITABLE]  = true;
2287   states[State::FOCUSABLE] = true;
2288
2289   Toolkit::Control focusControl = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
2290   if(mSelf == focusControl)
2291   {
2292     states[State::FOCUSED] = true;
2293   }
2294
2295   return states;
2296 }
2297
2298 bool TextField::AccessibleImpl::InsertText(size_t startPosition, std::string text)
2299 {
2300   auto self         = Toolkit::TextField::DownCast(Self());
2301   auto insertedText = self.GetProperty(Toolkit::TextField::Property::TEXT).Get<std::string>();
2302
2303   insertedText.insert(startPosition, text);
2304
2305   self.SetProperty(Toolkit::TextField::Property::TEXT, std::move(insertedText));
2306
2307   return true;
2308 }
2309
2310 bool TextField::AccessibleImpl::SetTextContents(std::string newContents)
2311 {
2312   auto self = Toolkit::TextField::DownCast(Self());
2313   self.SetProperty(Toolkit::TextField::Property::TEXT, std::move(newContents));
2314   return true;
2315 }
2316
2317 } // namespace Internal
2318
2319 } // namespace Toolkit
2320
2321 } // namespace Dali