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