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