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 bool TextEditor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1104 {
1105   Dali::BaseHandle handle( object );
1106
1107   bool connected( true );
1108   Toolkit::TextEditor editor = Toolkit::TextEditor::DownCast( handle );
1109
1110   if( 0 == strcmp( signalName.c_str(), SIGNAL_TEXT_CHANGED ) )
1111   {
1112     editor.TextChangedSignal().Connect( tracker, functor );
1113   }
1114   else if( 0 == strcmp( signalName.c_str(), SIGNAL_INPUT_STYLE_CHANGED ) )
1115   {
1116     editor.InputStyleChangedSignal().Connect( tracker, functor );
1117   }
1118   else if( 0 == strcmp( signalName.c_str(), SIGNAL_MAX_LENGTH_REACHED ) )
1119   {
1120     if( editor )
1121     {
1122       Internal::TextEditor& editorImpl( GetImpl( editor ) );
1123       editorImpl.MaxLengthReachedSignal().Connect( tracker, functor );
1124     }
1125   }
1126   else
1127   {
1128     // signalName does not match any signal
1129     connected = false;
1130   }
1131
1132   return connected;
1133 }
1134
1135 Toolkit::TextEditor::TextChangedSignalType& TextEditor::TextChangedSignal()
1136 {
1137   return mTextChangedSignal;
1138 }
1139
1140 Toolkit::TextEditor::InputStyleChangedSignalType& TextEditor::InputStyleChangedSignal()
1141 {
1142   return mInputStyleChangedSignal;
1143 }
1144
1145 Toolkit::TextEditor::ScrollStateChangedSignalType& TextEditor::ScrollStateChangedSignal()
1146 {
1147   return mScrollStateChangedSignal;
1148 }
1149
1150 void TextEditor::OnInitialize()
1151 {
1152   Actor self = Self();
1153
1154   mController = Text::Controller::New( this, this, this);
1155
1156   mDecorator = Text::Decorator::New( *mController,
1157                                      *mController );
1158
1159   mInputMethodContext = InputMethodContext::New( self );
1160
1161   mController->GetLayoutEngine().SetLayout( Layout::Engine::MULTI_LINE_BOX );
1162
1163   // Enables the text input.
1164   mController->EnableTextInput( mDecorator, mInputMethodContext );
1165
1166   // Enables the vertical scrolling after the text input has been enabled.
1167   mController->SetVerticalScrollEnabled( true );
1168
1169   // Disables the horizontal scrolling.
1170   mController->SetHorizontalScrollEnabled( false );
1171
1172   // Sets the maximum number of characters.
1173   mController->SetMaximumNumberOfCharacters( std::numeric_limits<Length>::max() );
1174
1175   // Enable the smooth handle panning.
1176   mController->SetSmoothHandlePanEnabled( true );
1177
1178   mController->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
1179   mController->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
1180
1181   // Sets layoutDirection value
1182   Dali::Stage stage = Dali::Stage::GetCurrent();
1183   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( stage.GetRootLayer().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
1184   mController->SetLayoutDirection( layoutDirection );
1185
1186   // Forward input events to controller
1187   EnableGestureDetection( static_cast<GestureType::Value>( GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS ) );
1188   GetTapGestureDetector().SetMaximumTapsRequired( 2 );
1189
1190   self.TouchedSignal().Connect( this, &TextEditor::OnTouched );
1191
1192   // Set BoundingBox to stage size if not already set.
1193   Rect<int> boundingBox;
1194   mDecorator->GetBoundingBox( boundingBox );
1195
1196   if( boundingBox.IsEmpty() )
1197   {
1198     Vector2 stageSize = Dali::Stage::GetCurrent().GetSize();
1199     mDecorator->SetBoundingBox( Rect<int>( 0.0f, 0.0f, stageSize.width, stageSize.height ) );
1200   }
1201
1202   // Whether to flip the selection handles as soon as they cross.
1203   mDecorator->FlipSelectionHandlesOnCrossEnabled( true );
1204
1205   // Set the default scroll speed.
1206   mDecorator->SetScrollSpeed( DEFAULT_SCROLL_SPEED );
1207
1208   // Fill-parent area by default
1209   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
1210   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
1211   self.OnSceneSignal().Connect( this, &TextEditor::OnSceneConnect );
1212
1213   DevelControl::SetInputMethodContext( *this, mInputMethodContext );
1214
1215   // Creates an extra control to be used as stencil buffer.
1216   mStencil = Control::New();
1217   mStencil.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1218   mStencil.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1219
1220   // Creates a background visual. Even if the color is transparent it updates the stencil.
1221   mStencil.SetProperty( Toolkit::Control::Property::BACKGROUND,
1222                         Property::Map().Add( Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR ).
1223                         Add( ColorVisual::Property::MIX_COLOR, Color::TRANSPARENT ) );
1224
1225   // Enable the clipping property.
1226   mStencil.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
1227   mStencil.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
1228
1229   self.Add( mStencil );
1230 }
1231
1232 void TextEditor::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
1233 {
1234   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange\n");
1235
1236   switch ( change )
1237   {
1238     case StyleChange::DEFAULT_FONT_CHANGE:
1239     {
1240       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange DEFAULT_FONT_CHANGE\n");
1241       const std::string& newFont = GetImpl( styleManager ).GetDefaultFontFamily();
1242       // Property system did not set the font so should update it.
1243       mController->UpdateAfterFontChange( newFont );
1244       RelayoutRequest();
1245       break;
1246     }
1247
1248     case StyleChange::DEFAULT_FONT_SIZE_CHANGE:
1249     {
1250       GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
1251       RelayoutRequest();
1252       break;
1253     }
1254     case StyleChange::THEME_CHANGE:
1255     {
1256       // Nothing to do, let control base class handle this
1257       break;
1258     }
1259   }
1260
1261   // Up call to Control
1262   Control::OnStyleChange( styleManager, change );
1263 }
1264
1265 Vector3 TextEditor::GetNaturalSize()
1266 {
1267   Extents padding;
1268   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1269
1270   Vector3 naturalSize = mController->GetNaturalSize();
1271   naturalSize.width += ( padding.start + padding.end );
1272   naturalSize.height += ( padding.top + padding.bottom );
1273
1274   return naturalSize;
1275 }
1276
1277 float TextEditor::GetHeightForWidth( float width )
1278 {
1279   Extents padding;
1280   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1281   return mController->GetHeightForWidth( width ) + padding.top + padding.bottom;
1282 }
1283
1284 void TextEditor::OnRelayout( const Vector2& size, RelayoutContainer& container )
1285 {
1286   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor OnRelayout\n");
1287
1288   Actor self = Self();
1289
1290   Extents padding;
1291   padding = self.GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1292
1293   Vector2 contentSize( size.x - ( padding.start + padding.end ), size.y - ( padding.top + padding.bottom ) );
1294
1295   // Support Right-To-Left of padding
1296   Dali::LayoutDirection::Type layoutDirection;
1297   if( mController->IsMatchSystemLanguageDirection() )
1298   {
1299     layoutDirection = static_cast<Dali::LayoutDirection::Type>( DevelWindow::Get( self ).GetRootLayer().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
1300   }
1301   else
1302   {
1303     layoutDirection = static_cast<Dali::LayoutDirection::Type>( self.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
1304   }
1305   if( Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection )
1306   {
1307     std::swap( padding.start, padding.end );
1308   }
1309
1310   if( mStencil )
1311   {
1312     mStencil.SetProperty( Actor::Property::POSITION, Vector2( padding.start, padding.top ));
1313   }
1314   if( mActiveLayer )
1315   {
1316     mActiveLayer.SetProperty( Actor::Property::POSITION, Vector2( padding.start, padding.top ));
1317   }
1318
1319   const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize, layoutDirection );
1320
1321   if( ( Text::Controller::NONE_UPDATED != updateTextType ) ||
1322       !mRenderer )
1323   {
1324     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnRelayout %p Displaying new contents\n", mController.Get() );
1325
1326     if( mDecorator &&
1327         ( Text::Controller::NONE_UPDATED != ( Text::Controller::DECORATOR_UPDATED & updateTextType ) ) )
1328     {
1329       mDecorator->Relayout( size );
1330     }
1331
1332     if( !mRenderer )
1333     {
1334       mRenderer = Backend::Get().NewRenderer( mRenderingBackend );
1335     }
1336
1337     RenderText( updateTextType );
1338
1339   }
1340
1341   // The text-editor emits signals when the input style changes. These changes of style are
1342   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1343   // can't be emitted during the size negotiation as the callbacks may update the UI.
1344   // The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
1345   if( !mController->IsInputStyleChangedSignalsQueueEmpty() )
1346   {
1347     if( Adaptor::IsAvailable() )
1348     {
1349       Adaptor& adaptor = Adaptor::Get();
1350
1351       if( NULL == mIdleCallback )
1352       {
1353         // @note: The callback manager takes the ownership of the callback object.
1354         mIdleCallback = MakeCallback( this, &TextEditor::OnIdleSignal );
1355         adaptor.AddIdle( mIdleCallback, false );
1356       }
1357     }
1358   }
1359 }
1360
1361 void TextEditor::RenderText( Text::Controller::UpdateTextType updateTextType )
1362 {
1363   Actor renderableActor;
1364
1365   if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) )
1366   {
1367     if( mRenderer )
1368     {
1369       Dali::Toolkit::TextEditor handle = Dali::Toolkit::TextEditor( GetOwner() );
1370
1371       renderableActor = mRenderer->Render( mController->GetView(),
1372                                            handle,
1373                                            Property::INVALID_INDEX, // Animatable property not supported
1374                                            mAlignmentOffset,
1375                                            DepthIndex::CONTENT );
1376     }
1377
1378     if( renderableActor != mRenderableActor )
1379     {
1380       UnparentAndReset( mRenderableActor );
1381       mRenderableActor = renderableActor;
1382     }
1383   }
1384
1385   if( mRenderableActor )
1386   {
1387     // Make sure the actors are parented correctly with/without clipping
1388     Actor self = mStencil ? mStencil : Self();
1389
1390     for( std::vector<Actor>::iterator it = mClippingDecorationActors.begin(),
1391            endIt = mClippingDecorationActors.end();
1392          it != endIt;
1393          ++it )
1394     {
1395       self.Add( *it );
1396       it->LowerToBottom();
1397     }
1398     mClippingDecorationActors.clear();
1399
1400     self.Add( mRenderableActor );
1401
1402     ApplyScrollPosition();
1403   }
1404   UpdateScrollBar();
1405 }
1406
1407 void TextEditor::OnKeyInputFocusGained()
1408 {
1409   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnKeyInputFocusGained %p\n", mController.Get() );
1410   if ( mInputMethodContext  && IsEditable() )
1411   {
1412     mInputMethodContext.StatusChangedSignal().Connect( this, &TextEditor::KeyboardStatusChanged );
1413
1414     mInputMethodContext.EventReceivedSignal().Connect( this, &TextEditor::OnInputMethodContextEvent );
1415
1416     // Notify that the text editing start.
1417     mInputMethodContext.Activate();
1418
1419     // When window gain lost focus, the InputMethodContext is deactivated. Thus when window gain focus again, the InputMethodContext must be activated.
1420     mInputMethodContext.SetRestoreAfterFocusLost( true );
1421   }
1422   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
1423
1424   if ( notifier )
1425   {
1426     notifier.ContentSelectedSignal().Connect( this, &TextEditor::OnClipboardTextSelected );
1427   }
1428
1429   mController->KeyboardFocusGainEvent(); // Called in the case of no virtual keyboard to trigger this event
1430
1431   EmitKeyInputFocusSignal( true ); // Calls back into the Control hence done last.
1432 }
1433
1434 void TextEditor::OnKeyInputFocusLost()
1435 {
1436   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor:OnKeyInputFocusLost %p\n", mController.Get() );
1437   if ( mInputMethodContext )
1438   {
1439     mInputMethodContext.StatusChangedSignal().Disconnect( this, &TextEditor::KeyboardStatusChanged );
1440
1441     // The text editing is finished. Therefore the InputMethodContext don't have restore activation.
1442     mInputMethodContext.SetRestoreAfterFocusLost( false );
1443
1444     // Notify that the text editing finish.
1445     mInputMethodContext.Deactivate();
1446
1447     mInputMethodContext.EventReceivedSignal().Disconnect( this, &TextEditor::OnInputMethodContextEvent );
1448   }
1449   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
1450
1451   if ( notifier )
1452   {
1453     notifier.ContentSelectedSignal().Disconnect( this, &TextEditor::OnClipboardTextSelected );
1454   }
1455
1456   mController->KeyboardFocusLostEvent();
1457
1458   EmitKeyInputFocusSignal( false ); // Calls back into the Control hence done last.
1459 }
1460
1461 void TextEditor::OnTap( const TapGesture& gesture )
1462 {
1463   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnTap %p\n", mController.Get() );
1464   if ( mInputMethodContext && IsEditable() )
1465   {
1466     mInputMethodContext.Activate();
1467   }
1468   // Deliver the tap before the focus event to controller; this allows us to detect when focus is gained due to tap-gestures
1469   Extents padding;
1470   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1471   const Vector2& localPoint = gesture.GetLocalPoint();
1472   mController->TapEvent( gesture.GetNumberOfTaps(), localPoint.x - padding.start, localPoint.y - padding.top );
1473
1474   SetKeyInputFocus();
1475 }
1476
1477 void TextEditor::OnPan( const PanGesture& gesture )
1478 {
1479   mController->PanEvent( gesture.GetState(), gesture.GetDisplacement() );
1480 }
1481
1482 void TextEditor::OnLongPress( const LongPressGesture& gesture )
1483 {
1484   if ( mInputMethodContext && IsEditable() )
1485   {
1486     mInputMethodContext.Activate();
1487   }
1488   Extents padding;
1489   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1490   const Vector2& localPoint = gesture.GetLocalPoint();
1491   mController->LongPressEvent( gesture.GetState(), localPoint.x - padding.start, localPoint.y - padding.top );
1492
1493   SetKeyInputFocus();
1494 }
1495
1496 bool TextEditor::OnKeyEvent( const KeyEvent& event )
1497 {
1498   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnKeyEvent %p keyCode %d\n", mController.Get(), event.GetKeyCode() );
1499
1500   if( Dali::DALI_KEY_ESCAPE == event.GetKeyCode() && mController->ShouldClearFocusOnEscape() )
1501   {
1502     // Make sure ClearKeyInputFocus when only key is up
1503     if( event.GetState() == KeyEvent::UP )
1504     {
1505       ClearKeyInputFocus();
1506     }
1507
1508     return true;
1509   }
1510
1511   return mController->KeyEvent( event );
1512 }
1513
1514 void TextEditor::RequestTextRelayout()
1515 {
1516   RelayoutRequest();
1517 }
1518
1519 void TextEditor::TextChanged()
1520 {
1521   Dali::Toolkit::TextEditor handle( GetOwner() );
1522   mTextChangedSignal.Emit( handle );
1523 }
1524
1525 void TextEditor::MaxLengthReached()
1526 {
1527   Dali::Toolkit::TextEditor handle( GetOwner() );
1528   mMaxLengthReachedSignal.Emit( handle );
1529 }
1530
1531 void TextEditor::InputStyleChanged( Text::InputStyle::Mask inputStyleMask )
1532 {
1533   Dali::Toolkit::TextEditor handle( GetOwner() );
1534
1535   Toolkit::TextEditor::InputStyle::Mask editorInputStyleMask = Toolkit::TextEditor::InputStyle::NONE;
1536
1537   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_COLOR ) )
1538   {
1539     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::COLOR );
1540   }
1541   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_FAMILY ) )
1542   {
1543     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_FAMILY );
1544   }
1545   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_POINT_SIZE ) )
1546   {
1547     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::POINT_SIZE );
1548   }
1549   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_WEIGHT ) )
1550   {
1551     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1552   }
1553   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_WIDTH ) )
1554   {
1555     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1556   }
1557   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_SLANT ) )
1558   {
1559     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1560   }
1561   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_LINE_SPACING ) )
1562   {
1563     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::LINE_SPACING );
1564   }
1565   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_UNDERLINE ) )
1566   {
1567     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::UNDERLINE );
1568   }
1569   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_SHADOW ) )
1570   {
1571     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::SHADOW );
1572   }
1573   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_EMBOSS ) )
1574   {
1575     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::EMBOSS );
1576   }
1577   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_OUTLINE ) )
1578   {
1579     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::OUTLINE );
1580   }
1581
1582   mInputStyleChangedSignal.Emit( handle, editorInputStyleMask );
1583 }
1584
1585 void TextEditor::AddDecoration( Actor& actor, bool needsClipping )
1586 {
1587   if( actor )
1588   {
1589     if( needsClipping )
1590     {
1591       mClippingDecorationActors.push_back( actor );
1592     }
1593     else
1594     {
1595       actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1596       actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1597       Self().Add( actor );
1598       mActiveLayer = actor;
1599     }
1600   }
1601 }
1602
1603 void TextEditor::SetTextSelectionRange(const uint32_t *start, const uint32_t *end)
1604 {
1605   if( mController && mController->IsShowingRealText() )
1606   {
1607     mController->SetTextSelectionRange( start, end );
1608     SetKeyInputFocus();
1609   }
1610 }
1611
1612 Uint32Pair TextEditor::GetTextSelectionRange() const
1613 {
1614   Uint32Pair range(0, 0);
1615   if( mController && mController->IsShowingRealText() )
1616   {
1617     range = mController->GetTextSelectionRange();
1618   }
1619   return range;
1620 }
1621
1622 void TextEditor::UpdateScrollBar()
1623 {
1624   using namespace Dali;
1625
1626   float scrollPosition;
1627   float controlSize;
1628   float layoutSize;
1629   bool latestScrolled;
1630
1631   if ( !mScrollBarEnabled )
1632   {
1633     return;
1634   }
1635   latestScrolled = mController->GetTextScrollInfo( scrollPosition, controlSize, layoutSize );
1636   if ( !latestScrolled || controlSize > layoutSize)
1637   {
1638     return;
1639   }
1640
1641   CustomActor self = Self();
1642   if( !mScrollBar )
1643   {
1644     mScrollBar = Toolkit::ScrollBar::New( Toolkit::ScrollBar::VERTICAL );
1645     mScrollBar.SetIndicatorHeightPolicy( Toolkit::ScrollBar::VARIABLE );
1646     mScrollBar.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
1647     mScrollBar.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_RIGHT );
1648     mScrollBar.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
1649     mScrollBar.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
1650
1651     // Register the scroll position property
1652     Property::Index propertyScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION, scrollPosition );
1653     // Register the minimum scroll position property
1654     Property::Index propertyMinScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION_MIN, 0.0f );
1655     // Register the maximum scroll position property
1656     Property::Index propertyMaxScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION_MAX, (layoutSize - controlSize) );
1657     // Register the scroll content size property
1658     Property::Index propertyScrollContentSize = self.RegisterProperty( SCROLL_BAR_CONTENT_SIZE, layoutSize );
1659
1660     mScrollBar.SetScrollPropertySource(self, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
1661
1662     // Set style name of ScrollBar for styling
1663     mScrollBar.SetStyleName("TextEditorScrollBar");
1664     Toolkit::Control scrollIndicator = Toolkit::Control::DownCast( mScrollBar.GetScrollIndicator() );
1665     if( scrollIndicator )
1666     {
1667       // Set style name of ScrollBarIndicator for styling
1668       scrollIndicator.SetStyleName("TextEditorScrollBarIndicator");
1669     }
1670
1671     self.Add( mScrollBar );
1672   }
1673   else
1674   {
1675     Property::Index propertyScrollPosition = self.GetPropertyIndex( SCROLL_BAR_POSITION );
1676     Property::Index propertyMaxScrollPosition = self.GetPropertyIndex( SCROLL_BAR_POSITION_MAX );
1677     Property::Index propertyScrollContentSize = self.GetPropertyIndex( SCROLL_BAR_CONTENT_SIZE );
1678
1679     self.SetProperty( propertyScrollPosition, scrollPosition );
1680     self.SetProperty( propertyMaxScrollPosition, (layoutSize - controlSize) );
1681     self.SetProperty( propertyScrollContentSize, layoutSize );
1682   }
1683
1684   // If scrolling is not started, start scrolling and emit ScrollStateChangedSignal
1685   if( !mScrollStarted )
1686   {
1687     mScrollStarted = true;
1688     Dali::Toolkit::TextEditor handle( GetOwner() );
1689     mScrollStateChangedSignal.Emit( handle, Toolkit::TextEditor::Scroll::STARTED );
1690   }
1691
1692   Actor indicator = mScrollBar.GetScrollIndicator();
1693   if( mAnimation )
1694   {
1695     mAnimation.Stop(); // Cancel any animation
1696   }
1697   else
1698   {
1699     mAnimation = Animation::New( mAnimationPeriod.durationSeconds );
1700   }
1701   indicator.SetProperty( Actor::Property::OPACITY,1.0f);
1702   mAnimation.AnimateTo( Property( indicator, Actor::Property::COLOR_ALPHA ), 0.0f, AlphaFunction::EASE_IN, mAnimationPeriod );
1703   mAnimation.Play();
1704   mAnimation.FinishedSignal().Connect( this, &TextEditor::OnScrollIndicatorAnimationFinished );
1705 }
1706
1707 void TextEditor::OnScrollIndicatorAnimationFinished( Animation& animation )
1708 {
1709   // If animation is successfully ended, then emit ScrollStateChangedSignal
1710   if( animation.GetCurrentProgress() == 0.0f )
1711   {
1712     mScrollStarted = false;
1713     Dali::Toolkit::TextEditor handle( GetOwner() );
1714     mScrollStateChangedSignal.Emit( handle, Toolkit::TextEditor::Scroll::FINISHED );
1715   }
1716 }
1717
1718 void TextEditor::OnSceneConnect( Dali::Actor actor )
1719 {
1720   if ( mHasBeenStaged )
1721   {
1722     RenderText( static_cast<Text::Controller::UpdateTextType>( Text::Controller::MODEL_UPDATED | Text::Controller::DECORATOR_UPDATED ) );
1723   }
1724   else
1725   {
1726     mHasBeenStaged = true;
1727   }
1728 }
1729
1730 InputMethodContext::CallbackData TextEditor::OnInputMethodContextEvent( Dali::InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent )
1731 {
1732   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnInputMethodContextEvent %p eventName %d\n", mController.Get(), inputMethodContextEvent.eventName );
1733   return mController->OnInputMethodContextEvent( inputMethodContext, inputMethodContextEvent );
1734 }
1735
1736 void TextEditor::GetHandleImagePropertyValue(  Property::Value& value, Text::HandleType handleType, Text::HandleImageType handleImageType )
1737 {
1738   if( mDecorator )
1739   {
1740     Property::Map map;
1741     map[ IMAGE_MAP_FILENAME_STRING ] = mDecorator->GetHandleImage( handleType, handleImageType );
1742     value = map;
1743   }
1744 }
1745
1746 void TextEditor::OnClipboardTextSelected( ClipboardEventNotifier& clipboard )
1747 {
1748   mController->PasteClipboardItemEvent();
1749 }
1750
1751 void TextEditor::KeyboardStatusChanged(bool keyboardShown)
1752 {
1753   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown );
1754
1755   // Just hide the grab handle when keyboard is hidden.
1756   if (!keyboardShown )
1757   {
1758     mController->KeyboardFocusLostEvent();
1759   }
1760   else
1761   {
1762     mController->KeyboardFocusGainEvent(); // Initially called by OnKeyInputFocusGained
1763   }
1764 }
1765
1766 void TextEditor::OnSceneConnection( int depth )
1767 {
1768   // Sets the depth to the visuals inside the text's decorator.
1769   mDecorator->SetTextDepth( depth );
1770
1771   // The depth of the text renderer is set in the RenderText() called from OnRelayout().
1772
1773   // Call the Control::OnSceneConnection() to set the depth of the background.
1774   Control::OnSceneConnection( depth );
1775 }
1776
1777 bool TextEditor::OnTouched( Actor actor, const TouchEvent& touch )
1778 {
1779   return false;
1780 }
1781
1782 void TextEditor::OnIdleSignal()
1783 {
1784   // Emits the change of input style signals.
1785   mController->ProcessInputStyleChangedSignals();
1786
1787   // Set the pointer to null as the callback manager deletes the callback after execute it.
1788   mIdleCallback = NULL;
1789 }
1790
1791 void TextEditor::ApplyScrollPosition()
1792 {
1793   const Vector2& scrollOffset = mController->GetTextModel()->GetScrollPosition();
1794   float scrollAmount = 0.0f;
1795
1796   if ( mScrollAnimationEnabled )
1797   {
1798     scrollAmount = mController->GetScrollAmountByUserInput();
1799   }
1800   if ( mTextVerticalScroller )
1801   {
1802     mTextVerticalScroller->CheckStartAnimation( mRenderableActor, scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount, scrollAmount );
1803   }
1804   else if ( Equals( scrollAmount, 0.0f, Math::MACHINE_EPSILON_1 ))
1805   {
1806     mRenderableActor.SetProperty( Actor::Property::POSITION, Vector2( scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount ));
1807   }
1808   else
1809   {
1810     mTextVerticalScroller = Text::TextVerticalScroller::New();
1811     if ( !Equals( mScrollAnimationDuration, 0.0f, Math::MACHINE_EPSILON_1 ))
1812     {
1813       mTextVerticalScroller->SetDuration( mScrollAnimationDuration );
1814     }
1815     mTextVerticalScroller->CheckStartAnimation( mRenderableActor, scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount, scrollAmount );
1816   }
1817 }
1818
1819 bool TextEditor::IsEditable() const
1820 {
1821   return mController->IsEditable();
1822 }
1823
1824 void TextEditor::SetEditable( bool editable )
1825 {
1826   mController->SetEditable(editable);
1827   if ( mInputMethodContext && !editable )
1828   {
1829     mInputMethodContext.Deactivate();
1830   }
1831 }
1832
1833 TextEditor::TextEditor()
1834 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
1835   mAnimationPeriod( 0.0f, 0.0f ),
1836   mIdleCallback( NULL ),
1837   mAlignmentOffset( 0.f ),
1838   mScrollAnimationDuration( 0.f ),
1839   mLineSpacing( 0.f ),
1840   mRenderingBackend( DEFAULT_RENDERING_BACKEND ),
1841   mHasBeenStaged( false ),
1842   mScrollAnimationEnabled( false ),
1843   mScrollBarEnabled( false ),
1844   mScrollStarted( false )
1845 {
1846 }
1847
1848 TextEditor::~TextEditor()
1849 {
1850   UnparentAndReset( mStencil );
1851
1852   if( ( NULL != mIdleCallback ) && Adaptor::IsAvailable() )
1853   {
1854     // Removes the callback from the callback manager in case the text-editor is destroyed before the callback is executed.
1855     Adaptor::Get().RemoveIdle( mIdleCallback );
1856   }
1857 }
1858
1859 } // namespace Internal
1860
1861 } // namespace Toolkit
1862
1863 } // namespace Dali