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