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