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