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

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