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