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