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