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