dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp

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