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

   1 /*
   2  * Copyright (c) 2017 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/stage.h>
  26 #include <dali/public-api/images/resource-image.h>
  27 #include <dali/devel-api/actors/actor-devel.h>
  28 #include <dali/devel-api/object/property-helper-devel.h>
  29 #include <dali/public-api/object/type-registry-helper.h>
  30 #include <dali/integration-api/adaptors/adaptor.h>
  31 #include <dali/integration-api/debug.h>
  32
  33 // INTERNAL INCLUDES
  34 #include <dali-toolkit/public-api/text/rendering-backend.h>
  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/controls/control-devel.h>
  38 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  39 #include <dali-toolkit/devel-api/controls/text-controls/text-editor-devel.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
  48 using namespace Dali::Toolkit::Text;
  49
  50 namespace Dali
  51 {
  52
  53 namespace Toolkit
  54 {
  55
  56 namespace Internal
  57 {
  58
  59 namespace // unnamed namespace
  60 {
  61
  62 #if defined(DEBUG_ENABLED)
  63 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_CONTROLS");
  64 #endif
  65
  66 const unsigned int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
  67 const float DEFAULT_SCROLL_SPEED = 1200.f; ///< The default scroll speed for the text editor in pixels/second.
  68 } // unnamed namespace
  69
  70 namespace
  71 {
  72 const char* const SCROLL_BAR_POSITION("sourcePosition");
  73 const char* const SCROLL_BAR_POSITION_MIN("sourcePositionMin");
  74 const char* const SCROLL_BAR_POSITION_MAX("sourcePositionMax");
  75 const char* const SCROLL_BAR_CONTENT_SIZE("sourceContentSize");
  76
  77 // Type registration
  78 BaseHandle Create()
  79 {
  80   return Toolkit::TextEditor::New();
  81 }
  82
  83 // Setup properties, signals and actions using the type-registry.
  84 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TextEditor, Toolkit::Control, Create );
  85
  86 DALI_PROPERTY_REGISTRATION( Toolkit, TextEditor, "renderingBackend",                     INTEGER,   RENDERING_BACKEND                    )
  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
 140 DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "textChanged",        SIGNAL_TEXT_CHANGED )
 141 DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "inputStyleChanged",  SIGNAL_INPUT_STYLE_CHANGED )
 142
 143 DALI_TYPE_REGISTRATION_END()
 144
 145 } // namespace
 146
 147 Toolkit::TextEditor TextEditor::New()
 148 {
 149   // Create the implementation, temporarily owned by this handle on stack
 150   IntrusivePtr< TextEditor > impl = new TextEditor();
 151
 152   // Pass ownership to CustomActor handle
 153   Toolkit::TextEditor handle( *impl );
 154
 155   // Second-phase init of the implementation
 156   // This can only be done after the CustomActor connection has been made...
 157   impl->Initialize();
 158
 159   return handle;
 160 }
 161
 162 void TextEditor::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 163 {
 164   Toolkit::TextEditor textEditor = Toolkit::TextEditor::DownCast( Dali::BaseHandle( object ) );
 165
 166   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor SetProperty\n");
 167
 168
 169   if( textEditor )
 170   {
 171     TextEditor& impl( GetImpl( textEditor ) );
 172
 173     switch( index )
 174     {
 175       case Toolkit::TextEditor::Property::RENDERING_BACKEND:
 176       {
 177         int backend = value.Get< int >();
 178         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p RENDERING_BACKEND %d\n", impl.mController.Get(), backend );
 179
 180         if( impl.mRenderingBackend != backend )
 181         {
 182           impl.mRenderingBackend = backend;
 183           impl.mRenderer.Reset();
 184           impl.RequestTextRelayout();
 185         }
 186         break;
 187       }
 188       case Toolkit::TextEditor::Property::TEXT:
 189       {
 190         if( impl.mController )
 191         {
 192           const std::string& text = value.Get< std::string >();
 193           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p TEXT %s\n", impl.mController.Get(), text.c_str() );
 194
 195           impl.mController->SetText( text );
 196         }
 197         break;
 198       }
 199       case Toolkit::TextEditor::Property::TEXT_COLOR:
 200       {
 201         if( impl.mController )
 202         {
 203           const Vector4& textColor = value.Get< Vector4 >();
 204           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 );
 205
 206           if( impl.mController->GetDefaultColor() != textColor )
 207           {
 208             impl.mController->SetDefaultColor( textColor );
 209             impl.mController->SetInputColor( textColor );
 210             impl.mRenderer.Reset();
 211           }
 212         }
 213         break;
 214       }
 215       case Toolkit::TextEditor::Property::FONT_FAMILY:
 216       {
 217         if( impl.mController )
 218         {
 219           const std::string& fontFamily = value.Get< std::string >();
 220           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str() );
 221           impl.mController->SetDefaultFontFamily( fontFamily );
 222         }
 223         break;
 224       }
 225       case Toolkit::TextEditor::Property::FONT_STYLE:
 226       {
 227         SetFontStyleProperty( impl.mController, value, Text::FontStyle::DEFAULT );
 228         break;
 229       }
 230       case Toolkit::TextEditor::Property::POINT_SIZE:
 231       {
 232         if( impl.mController )
 233         {
 234           const float pointSize = value.Get< float >();
 235           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p POINT_SIZE %f\n", impl.mController.Get(), pointSize );
 236
 237           if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
 238           {
 239             impl.mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
 240           }
 241         }
 242         break;
 243       }
 244       case Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT:
 245       {
 246         if( impl.mController )
 247         {
 248           Text::HorizontalAlignment::Type alignment( static_cast< Text::HorizontalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
 249           if( Text::GetHorizontalAlignmentEnumeration( value, alignment ) )
 250           {
 251             DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p HORIZONTAL_ALIGNMENT %d\n", impl.mController.Get(), alignment );
 252             impl.mController->SetHorizontalAlignment( alignment );
 253           }
 254         }
 255         break;
 256       }
 257       case Toolkit::TextEditor::Property::SCROLL_THRESHOLD:
 258       {
 259         const float threshold = value.Get< float >();
 260         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p SCROLL_THRESHOLD %f\n", impl.mController.Get(), threshold );
 261
 262         if( impl.mDecorator )
 263         {
 264           impl.mDecorator->SetScrollThreshold( threshold );
 265         }
 266         break;
 267       }
 268       case Toolkit::TextEditor::Property::SCROLL_SPEED:
 269       {
 270         const float speed = value.Get< float >();
 271         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p SCROLL_SPEED %f\n", impl.mController.Get(), speed );
 272
 273         if( impl.mDecorator )
 274         {
 275           impl.mDecorator->SetScrollSpeed( speed );
 276         }
 277         break;
 278       }
 279       case Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR:
 280       {
 281         if( impl.mDecorator )
 282         {
 283           const Vector4& color = value.Get< Vector4 >();
 284           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 );
 285
 286           impl.mDecorator->SetCursorColor( PRIMARY_CURSOR, color );
 287           impl.RequestTextRelayout();
 288         }
 289         break;
 290       }
 291       case Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR:
 292       {
 293         if( impl.mDecorator )
 294         {
 295           const Vector4& color = value.Get< Vector4 >();
 296           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 );
 297
 298           impl.mDecorator->SetCursorColor( SECONDARY_CURSOR, color );
 299           impl.RequestTextRelayout();
 300         }
 301         break;
 302       }
 303       case Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK:
 304       {
 305         if( impl.mController )
 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         }
 313         break;
 314       }
 315       case Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL:
 316       {
 317         if( impl.mDecorator )
 318         {
 319           const float interval = value.Get< float >();
 320           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p CURSOR_BLINK_INTERVAL %f\n", impl.mController.Get(), interval );
 321
 322           impl.mDecorator->SetCursorBlinkInterval( interval );
 323         }
 324         break;
 325       }
 326       case Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION:
 327       {
 328         if( impl.mDecorator )
 329         {
 330           const float duration = value.Get< float >();
 331           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p CURSOR_BLINK_DURATION %f\n", impl.mController.Get(), duration );
 332
 333           impl.mDecorator->SetCursorBlinkDuration( duration );
 334         }
 335         break;
 336       }
 337       case Toolkit::TextEditor::Property::CURSOR_WIDTH:
 338       {
 339         if( impl.mDecorator )
 340         {
 341           const int width = value.Get< int >();
 342           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p CURSOR_WIDTH %d\n", impl.mController.Get(), width );
 343
 344           impl.mDecorator->SetCursorWidth( width );
 345           impl.mController->GetLayoutEngine().SetCursorWidth( width );
 346         }
 347         break;
 348       }
 349       case Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE:
 350       {
 351         const ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 352         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p GRAB_HANDLE_IMAGE %s\n", impl.mController.Get(), image.GetUrl().c_str() );
 353
 354         if( impl.mDecorator )
 355         {
 356           impl.mDecorator->SetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_RELEASED, image );
 357           impl.RequestTextRelayout();
 358         }
 359         break;
 360       }
 361       case Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE:
 362       {
 363         const ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 364         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor %p GRAB_HANDLE_PRESSED_IMAGE %s\n", impl.mController.Get(), image.GetUrl().c_str() );
 365
 366         if( impl.mDecorator )
 367         {
 368           impl.mDecorator->SetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_PRESSED, image );
 369           impl.RequestTextRelayout();
 370         }
 371         break;
 372       }
 373       case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT:
 374       {
 375         const Image image = Scripting::NewImage( value );
 376
 377         if( impl.mDecorator && image )
 378         {
 379           impl.mDecorator->SetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, image );
 380           impl.RequestTextRelayout();
 381         }
 382         break;
 383       }
 384       case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 385       {
 386         const Image image = Scripting::NewImage( value );
 387
 388         if( impl.mDecorator && image )
 389         {
 390           impl.mDecorator->SetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, image );
 391           impl.RequestTextRelayout();
 392         }
 393         break;
 394       }
 395       case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 396       {
 397         const Image image = Scripting::NewImage( value );
 398
 399         if( impl.mDecorator && image )
 400         {
 401           impl.mDecorator->SetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, image );
 402           impl.RequestTextRelayout();
 403         }
 404         break;
 405       }
 406       case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 407       {
 408         const Image image = Scripting::NewImage( value );
 409
 410         if( impl.mDecorator && image )
 411         {
 412           impl.mDecorator->SetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, image );
 413           impl.RequestTextRelayout();
 414         }
 415         break;
 416       }
 417       case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 418       {
 419         const Image image = Scripting::NewImage( value );
 420
 421         if( impl.mDecorator && image )
 422         {
 423           impl.mDecorator->SetHandleImage( LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, image );
 424           impl.RequestTextRelayout();
 425         }
 426         break;
 427       }
 428       case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 429       {
 430         const Image image = Scripting::NewImage( value );
 431
 432         if( impl.mDecorator && image )
 433         {
 434           impl.mDecorator->SetHandleImage( RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED, image );
 435           impl.RequestTextRelayout();
 436         }
 437         break;
 438       }
 439       case Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR:
 440       {
 441         const Vector4 color = value.Get< Vector4 >();
 442         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 );
 443
 444         if( impl.mDecorator )
 445         {
 446           impl.mDecorator->SetHighlightColor( color );
 447           impl.RequestTextRelayout();
 448         }
 449         break;
 450       }
 451       case Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX:
 452       {
 453         if( impl.mDecorator )
 454         {
 455           const Rect<int>& box = value.Get< Rect<int> >();
 456           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 );
 457
 458           impl.mDecorator->SetBoundingBox( box );
 459           impl.RequestTextRelayout();
 460         }
 461         break;
 462       }
 463       case Toolkit::TextEditor::Property::ENABLE_MARKUP:
 464       {
 465         if( impl.mController )
 466         {
 467           const bool enableMarkup = value.Get<bool>();
 468           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p ENABLE_MARKUP %d\n", impl.mController.Get(), enableMarkup );
 469
 470           impl.mController->SetMarkupProcessorEnabled( enableMarkup );
 471         }
 472         break;
 473       }
 474       case Toolkit::TextEditor::Property::INPUT_COLOR:
 475       {
 476         if( impl.mController )
 477         {
 478           const Vector4& inputColor = value.Get< Vector4 >();
 479           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 );
 480
 481           impl.mController->SetInputColor( inputColor );
 482         }
 483         break;
 484       }
 485       case Toolkit::TextEditor::Property::INPUT_FONT_FAMILY:
 486       {
 487         if( impl.mController )
 488         {
 489           const std::string& fontFamily = value.Get< std::string >();
 490           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p INPUT_FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str() );
 491           impl.mController->SetInputFontFamily( fontFamily );
 492         }
 493         break;
 494       }
 495       case Toolkit::TextEditor::Property::INPUT_FONT_STYLE:
 496       {
 497         SetFontStyleProperty( impl.mController, value, Text::FontStyle::INPUT );
 498         break;
 499       }
 500       case Toolkit::TextEditor::Property::INPUT_POINT_SIZE:
 501       {
 502         if( impl.mController )
 503         {
 504           const float pointSize = value.Get< float >();
 505           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p INPUT_POINT_SIZE %f\n", impl.mController.Get(), pointSize );
 506           impl.mController->SetInputFontPointSize( pointSize );
 507         }
 508         break;
 509       }
 510       case Toolkit::TextEditor::Property::LINE_SPACING:
 511       {
 512         if( impl.mController )
 513         {
 514
 515           // The line spacing isn't supported by the TextEditor. Since it's supported
 516           // by the TextLabel for now it must be ignored. The property is being shadowed
 517           // locally so its value isn't affected.
 518           const float lineSpacing = value.Get<float>();
 519           impl.mLineSpacing = lineSpacing;
 520           // set it to 0.0 due to missing implementation
 521           impl.mController->SetDefaultLineSpacing( 0.0f );
 522           impl.mRenderer.Reset();
 523         }
 524         break;
 525       }
 526       case Toolkit::TextEditor::Property::INPUT_LINE_SPACING:
 527       {
 528         if( impl.mController )
 529         {
 530           const float lineSpacing = value.Get<float>();
 531           impl.mController->SetInputLineSpacing( lineSpacing );
 532           impl.mRenderer.Reset();
 533         }
 534         break;
 535       }
 536       case Toolkit::TextEditor::Property::UNDERLINE:
 537       {
 538         const bool update = SetUnderlineProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
 539         if( update )
 540         {
 541           impl.mRenderer.Reset();
 542         }
 543         break;
 544       }
 545       case Toolkit::TextEditor::Property::INPUT_UNDERLINE:
 546       {
 547         const bool update = SetUnderlineProperties( impl.mController, value, Text::EffectStyle::INPUT );
 548         if( update )
 549         {
 550           impl.mRenderer.Reset();
 551         }
 552         break;
 553       }
 554       case Toolkit::TextEditor::Property::SHADOW:
 555       {
 556         const bool update = SetShadowProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
 557         if( update )
 558         {
 559           impl.mRenderer.Reset();
 560         }
 561         break;
 562       }
 563       case Toolkit::TextEditor::Property::INPUT_SHADOW:
 564       {
 565         const bool update = SetShadowProperties( impl.mController, value, Text::EffectStyle::INPUT );
 566         if( update )
 567         {
 568           impl.mRenderer.Reset();
 569         }
 570         break;
 571       }
 572       case Toolkit::TextEditor::Property::EMBOSS:
 573       {
 574         const bool update = SetEmbossProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
 575         if( update )
 576         {
 577           impl.mRenderer.Reset();
 578         }
 579         break;
 580       }
 581       case Toolkit::TextEditor::Property::INPUT_EMBOSS:
 582       {
 583         const bool update = SetEmbossProperties( impl.mController, value, Text::EffectStyle::INPUT );
 584         if( update )
 585         {
 586           impl.mRenderer.Reset();
 587         }
 588         break;
 589       }
 590       case Toolkit::TextEditor::Property::OUTLINE:
 591       {
 592         const bool update = SetOutlineProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
 593         if( update )
 594         {
 595           impl.mRenderer.Reset();
 596         }
 597         break;
 598       }
 599       case Toolkit::TextEditor::Property::INPUT_OUTLINE:
 600       {
 601         const bool update = SetOutlineProperties( impl.mController, value, Text::EffectStyle::INPUT );
 602         if( update )
 603         {
 604           impl.mRenderer.Reset();
 605         }
 606         break;
 607       }
 608       case Toolkit::TextEditor::Property::SMOOTH_SCROLL:
 609       {
 610         const bool enable = value.Get< bool >();
 611         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor SMOOTH_SCROLL %d\n", enable );
 612
 613         impl.mScrollAnimationEnabled = enable;
 614         break;
 615       }
 616       case Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION:
 617       {
 618         const float duration = value.Get< float >();
 619         DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor SMOOTH_SCROLL_DURATION %f\n", duration );
 620
 621         impl.mScrollAnimationDuration = duration;
 622         if ( impl.mTextVerticalScroller )
 623         {
 624           impl.mTextVerticalScroller->SetDuration( duration );
 625         }
 626         break;
 627       }
 628       case Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR:
 629       {
 630         const bool enable = value.Get< bool >();
 631         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor SHOW_SCROLL_BAR %d\n", enable );
 632
 633         impl.mScrollBarEnabled = enable;
 634         break;
 635       }
 636       case Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION:
 637       {
 638         const float duration = value.Get< float >();
 639         DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor SCROLL_BAR_SHOW_DURATION %f\n", duration );
 640
 641         impl.mAnimationPeriod.delaySeconds = duration;
 642         break;
 643       }
 644       case Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION:
 645       {
 646         const float duration = value.Get< float >();
 647         DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor SCROLL_BAR_FADE_DURATION %f\n", duration );
 648
 649         impl.mAnimationPeriod.durationSeconds = duration;
 650         break;
 651       }
 652       case Toolkit::TextEditor::Property::PIXEL_SIZE:
 653       {
 654         if( impl.mController )
 655         {
 656           const float pixelSize = value.Get< float >();
 657           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize );
 658
 659           if( !Equals( impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
 660           {
 661             impl.mController->SetDefaultFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
 662           }
 663         }
 664         break;
 665       }
 666       case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT:
 667       {
 668         if( impl.mController )
 669         {
 670           const std::string& text = value.Get< std::string >();
 671           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor::OnPropertySet %p PLACEHOLDER_TEXT %s\n", impl.mController.Get(), text.c_str() );
 672
 673           impl.mController->SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text );
 674         }
 675         break;
 676       }
 677       case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR:
 678       {
 679         if( impl.mController )
 680         {
 681           const Vector4& textColor = value.Get< Vector4 >();
 682           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 );
 683
 684           if( impl.mController->GetPlaceholderTextColor() != textColor )
 685           {
 686             impl.mController->SetPlaceholderTextColor( textColor );
 687             impl.mRenderer.Reset();
 688           }
 689         }
 690         break;
 691       }
 692       case Toolkit::TextEditor::Property::ENABLE_SELECTION:
 693       {
 694         if( impl.mController )
 695         {
 696           const bool enableSelection = value.Get< bool >();
 697           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p ENABLE_SELECTION %d\n", impl.mController.Get(), enableSelection );
 698           impl.mController->SetSelectionEnabled( enableSelection );
 699         }
 700         break;
 701       }
 702       case Toolkit::TextEditor::Property::PLACEHOLDER:
 703       {
 704         const Property::Map* map = value.GetMap();
 705         if( map )
 706         {
 707           impl.mController->SetPlaceholderProperty( *map );
 708         }
 709         break;
 710       }
 711       case Toolkit::TextEditor::Property::LINE_WRAP_MODE:
 712       {
 713         if( impl.mController )
 714         {
 715           Text::LineWrap::Mode lineWrapMode( static_cast< Text::LineWrap::Mode >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
 716           if( GetLineWrapModeEnumeration( value, lineWrapMode ) )
 717           {
 718             DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p LineWrap::MODE %d\n", impl.mController.Get(), lineWrapMode );
 719             impl.mController->SetLineWrapMode( lineWrapMode );
 720           }
 721         }
 722         break;
 723       }
 724       case Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION:
 725       {
 726         if( impl.mController )
 727         {
 728           const bool shiftSelection = value.Get<bool>();
 729           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p ENABLE_SHIFT_SELECTION %d\n", impl.mController.Get(), shiftSelection );
 730
 731           impl.mController->SetShiftSelectionEnabled( shiftSelection );
 732         }
 733         break;
 734       }
 735     } // switch
 736   } // texteditor
 737 }
 738
 739 Property::Value TextEditor::GetProperty( BaseObject* object, Property::Index index )
 740 {
 741   Property::Value value;
 742
 743   Toolkit::TextEditor textEditor = Toolkit::TextEditor::DownCast( Dali::BaseHandle( object ) );
 744
 745   if( textEditor )
 746   {
 747     TextEditor& impl( GetImpl( textEditor ) );
 748
 749     switch( index )
 750     {
 751       case Toolkit::TextEditor::Property::RENDERING_BACKEND:
 752       {
 753         value = impl.mRenderingBackend;
 754         break;
 755       }
 756       case Toolkit::TextEditor::Property::TEXT:
 757       {
 758         if( impl.mController )
 759         {
 760           std::string text;
 761           impl.mController->GetText( text );
 762           DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p returning text: %s\n", impl.mController.Get(), text.c_str() );
 763           value = text;
 764         }
 765         break;
 766       }
 767       case Toolkit::TextEditor::Property::TEXT_COLOR:
 768       {
 769         if ( impl.mController )
 770         {
 771           value = impl.mController->GetDefaultColor();
 772         }
 773         break;
 774       }
 775       case Toolkit::TextEditor::Property::FONT_FAMILY:
 776       {
 777         if( impl.mController )
 778         {
 779           value = impl.mController->GetDefaultFontFamily();
 780         }
 781         break;
 782       }
 783       case Toolkit::TextEditor::Property::FONT_STYLE:
 784       {
 785         GetFontStyleProperty( impl.mController, value, Text::FontStyle::DEFAULT );
 786         break;
 787       }
 788       case Toolkit::TextEditor::Property::POINT_SIZE:
 789       {
 790         if( impl.mController )
 791         {
 792           value = impl.mController->GetDefaultFontSize( Text::Controller::POINT_SIZE );
 793         }
 794         break;
 795       }
 796       case Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT:
 797       {
 798         if( impl.mController )
 799         {
 800           const char* name = GetHorizontalAlignmentString( impl.mController->GetHorizontalAlignment() );
 801           if( name )
 802           {
 803             value = std::string( name );
 804           }
 805         }
 806         break;
 807       }
 808       case Toolkit::TextEditor::Property::SCROLL_THRESHOLD:
 809       {
 810         if( impl.mDecorator )
 811         {
 812           value = impl.mDecorator->GetScrollThreshold();
 813         }
 814         break;
 815       }
 816       case Toolkit::TextEditor::Property::SCROLL_SPEED:
 817       {
 818         if( impl.mDecorator )
 819         {
 820           value = impl.mDecorator->GetScrollSpeed();
 821         }
 822         break;
 823       }
 824       case Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR:
 825       {
 826         if( impl.mDecorator )
 827         {
 828           value = impl.mDecorator->GetColor( PRIMARY_CURSOR );
 829         }
 830         break;
 831       }
 832       case Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR:
 833       {
 834         if( impl.mDecorator )
 835         {
 836           value = impl.mDecorator->GetColor( SECONDARY_CURSOR );
 837         }
 838         break;
 839       }
 840       case Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK:
 841       {
 842         value = impl.mController->GetEnableCursorBlink();
 843         break;
 844       }
 845       case Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL:
 846       {
 847         if( impl.mDecorator )
 848         {
 849           value = impl.mDecorator->GetCursorBlinkInterval();
 850         }
 851         break;
 852       }
 853       case Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION:
 854       {
 855         if( impl.mDecorator )
 856         {
 857           value = impl.mDecorator->GetCursorBlinkDuration();
 858         }
 859         break;
 860       }
 861       case Toolkit::TextEditor::Property::CURSOR_WIDTH:
 862       {
 863         if( impl.mDecorator )
 864         {
 865           value = impl.mDecorator->GetCursorWidth();
 866         }
 867         break;
 868       }
 869       case Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE:
 870       {
 871         if( impl.mDecorator )
 872         {
 873           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_RELEASED ) );
 874           if( image )
 875           {
 876             value = image.GetUrl();
 877           }
 878         }
 879         break;
 880       }
 881       case Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE:
 882       {
 883         if( impl.mDecorator )
 884         {
 885           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_PRESSED ) );
 886           if( image )
 887           {
 888             value = image.GetUrl();
 889           }
 890         }
 891         break;
 892       }
 893       case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT:
 894       {
 895         impl.GetHandleImagePropertyValue( value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED );
 896         break;
 897       }
 898       case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 899       {
 900         impl.GetHandleImagePropertyValue( value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED ) ;
 901         break;
 902       }
 903       case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 904       {
 905         impl.GetHandleImagePropertyValue( value, LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED );
 906         break;
 907       }
 908       case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 909       {
 910         impl.GetHandleImagePropertyValue( value, RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED );
 911         break;
 912       }
 913       case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 914       {
 915         impl.GetHandleImagePropertyValue( value, LEFT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED );
 916         break;
 917       }
 918       case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 919       {
 920         impl.GetHandleImagePropertyValue( value, RIGHT_SELECTION_HANDLE_MARKER, HANDLE_IMAGE_RELEASED );
 921         break;
 922       }
 923       case Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR:
 924       {
 925         if( impl.mDecorator )
 926         {
 927           value = impl.mDecorator->GetHighlightColor();
 928         }
 929         break;
 930       }
 931       case Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX:
 932       {
 933         if( impl.mDecorator )
 934         {
 935           Rect<int> boundingBox;
 936           impl.mDecorator->GetBoundingBox( boundingBox );
 937           value = boundingBox;
 938         }
 939         break;
 940       }
 941       case Toolkit::TextEditor::Property::ENABLE_MARKUP:
 942       {
 943         if( impl.mController )
 944         {
 945           value = impl.mController->IsMarkupProcessorEnabled();
 946         }
 947         break;
 948       }
 949       case Toolkit::TextEditor::Property::INPUT_COLOR:
 950       {
 951         if( impl.mController )
 952         {
 953           value = impl.mController->GetInputColor();
 954         }
 955         break;
 956       }
 957       case Toolkit::TextEditor::Property::INPUT_FONT_FAMILY:
 958       {
 959         if( impl.mController )
 960         {
 961           value = impl.mController->GetInputFontFamily();
 962         }
 963         break;
 964       }
 965       case Toolkit::TextEditor::Property::INPUT_FONT_STYLE:
 966       {
 967         GetFontStyleProperty( impl.mController, value, Text::FontStyle::INPUT );
 968         break;
 969       }
 970       case Toolkit::TextEditor::Property::INPUT_POINT_SIZE:
 971       {
 972         if( impl.mController )
 973         {
 974           value = impl.mController->GetInputFontPointSize();
 975         }
 976         break;
 977       }
 978       case Toolkit::TextEditor::Property::LINE_SPACING:
 979       {
 980         if( impl.mController )
 981         {
 982           // LINE_SPACING isn't implemented for the TextEditor. Returning
 983           // only shadowed value, not the real one.
 984           value = impl.mLineSpacing;
 985         }
 986         break;
 987       }
 988       case Toolkit::TextEditor::Property::INPUT_LINE_SPACING:
 989       {
 990         if( impl.mController )
 991         {
 992           value = impl.mController->GetInputLineSpacing();
 993         }
 994         break;
 995       }
 996       case Toolkit::TextEditor::Property::UNDERLINE:
 997       {
 998         GetUnderlineProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
 999         break;
1000       }
1001       case Toolkit::TextEditor::Property::INPUT_UNDERLINE:
1002       {
1003         GetUnderlineProperties( impl.mController, value, Text::EffectStyle::INPUT );
1004         break;
1005       }
1006       case Toolkit::TextEditor::Property::SHADOW:
1007       {
1008         GetShadowProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
1009         break;
1010       }
1011       case Toolkit::TextEditor::Property::INPUT_SHADOW:
1012       {
1013         GetShadowProperties( impl.mController, value, Text::EffectStyle::INPUT );
1014         break;
1015       }
1016       case Toolkit::TextEditor::Property::EMBOSS:
1017       {
1018         GetEmbossProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
1019         break;
1020       }
1021       case Toolkit::TextEditor::Property::INPUT_EMBOSS:
1022       {
1023         GetEmbossProperties( impl.mController, value, Text::EffectStyle::INPUT );
1024         break;
1025       }
1026       case Toolkit::TextEditor::Property::OUTLINE:
1027       {
1028         GetOutlineProperties( impl.mController, value, Text::EffectStyle::DEFAULT );
1029         break;
1030       }
1031       case Toolkit::TextEditor::Property::INPUT_OUTLINE:
1032       {
1033         GetOutlineProperties( impl.mController, value, Text::EffectStyle::INPUT );
1034         break;
1035       }
1036       case Toolkit::TextEditor::Property::SMOOTH_SCROLL:
1037       {
1038         value = impl.mScrollAnimationEnabled;
1039         break;
1040       }
1041       case Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION:
1042       {
1043         value = impl.mScrollAnimationDuration;
1044         break;
1045       }
1046       case Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR:
1047       {
1048         value = impl.mScrollBarEnabled;
1049         break;
1050       }
1051       case Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION:
1052       {
1053         value = impl.mAnimationPeriod.delaySeconds;
1054         break;
1055       }
1056       case Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION:
1057       {
1058         value = impl.mAnimationPeriod.durationSeconds;
1059         break;
1060       }
1061       case Toolkit::TextEditor::Property::PIXEL_SIZE:
1062       {
1063         if( impl.mController )
1064         {
1065           value = impl.mController->GetDefaultFontSize( Text::Controller::PIXEL_SIZE );
1066         }
1067         break;
1068       }
1069       case Toolkit::TextEditor::Property::LINE_COUNT:
1070       {
1071         if( impl.mController )
1072         {
1073           float width = textEditor.GetProperty( Actor::Property::SIZE_WIDTH ).Get<float>();
1074           value = impl.mController->GetLineCount( width );
1075         }
1076         break;
1077       }
1078       case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT:
1079       {
1080         if( impl.mController )
1081         {
1082           std::string text;
1083           impl.mController->GetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text );
1084           value = text;
1085         }
1086         break;
1087       }
1088       case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR:
1089       {
1090         if( impl.mController )
1091         {
1092           value = impl.mController->GetPlaceholderTextColor();
1093         }
1094         break;
1095       }
1096       case Toolkit::TextEditor::Property::ENABLE_SELECTION:
1097       {
1098         if( impl.mController )
1099         {
1100           value = impl.mController->IsSelectionEnabled();
1101         }
1102         break;
1103       }
1104       case Toolkit::TextEditor::Property::PLACEHOLDER:
1105       {
1106         Property::Map map;
1107         impl.mController->GetPlaceholderProperty( map );
1108         value = map;
1109         break;
1110       }
1111       case Toolkit::TextEditor::Property::LINE_WRAP_MODE:
1112       {
1113         if( impl.mController )
1114         {
1115           value = impl.mController->GetLineWrapMode();
1116         }
1117         break;
1118       }
1119       case Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION:
1120       {
1121         if( impl.mController )
1122         {
1123           value = impl.mController->IsShiftSelectionEnabled();
1124         }
1125         break;
1126       }
1127     } //switch
1128   }
1129
1130   return value;
1131 }
1132
1133 bool TextEditor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1134 {
1135   Dali::BaseHandle handle( object );
1136
1137   bool connected( true );
1138   Toolkit::TextEditor editor = Toolkit::TextEditor::DownCast( handle );
1139
1140   if( 0 == strcmp( signalName.c_str(), SIGNAL_TEXT_CHANGED ) )
1141   {
1142     editor.TextChangedSignal().Connect( tracker, functor );
1143   }
1144   else if( 0 == strcmp( signalName.c_str(), SIGNAL_INPUT_STYLE_CHANGED ) )
1145   {
1146     editor.InputStyleChangedSignal().Connect( tracker, functor );
1147   }
1148   else
1149   {
1150     // signalName does not match any signal
1151     connected = false;
1152   }
1153
1154   return connected;
1155 }
1156
1157 Toolkit::TextEditor::TextChangedSignalType& TextEditor::TextChangedSignal()
1158 {
1159   return mTextChangedSignal;
1160 }
1161
1162 Toolkit::TextEditor::InputStyleChangedSignalType& TextEditor::InputStyleChangedSignal()
1163 {
1164   return mInputStyleChangedSignal;
1165 }
1166
1167 Toolkit::TextEditor::ScrollStateChangedSignalType& TextEditor::ScrollStateChangedSignal()
1168 {
1169   return mScrollStateChangedSignal;
1170 }
1171
1172 void TextEditor::OnInitialize()
1173 {
1174   Actor self = Self();
1175
1176   mController = Text::Controller::New( this, this );
1177
1178   mDecorator = Text::Decorator::New( *mController,
1179                                      *mController );
1180
1181   mController->GetLayoutEngine().SetLayout( Layout::Engine::MULTI_LINE_BOX );
1182
1183   // Enables the text input.
1184   mController->EnableTextInput( mDecorator );
1185
1186   // Enables the vertical scrolling after the text input has been enabled.
1187   mController->SetVerticalScrollEnabled( true );
1188
1189   // Disables the horizontal scrolling.
1190   mController->SetHorizontalScrollEnabled( false );
1191
1192   // Sets the maximum number of characters.
1193   mController->SetMaximumNumberOfCharacters( std::numeric_limits<Length>::max() );
1194
1195   // Enable the smooth handle panning.
1196   mController->SetSmoothHandlePanEnabled( true );
1197
1198   mController->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
1199   mController->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
1200
1201   // Forward input events to controller
1202   EnableGestureDetection( static_cast<Gesture::Type>( Gesture::Tap | Gesture::Pan | Gesture::LongPress ) );
1203   GetTapGestureDetector().SetMaximumTapsRequired( 2 );
1204
1205   mImfManager = ImfManager::Get();
1206
1207   self.TouchSignal().Connect( this, &TextEditor::OnTouched );
1208
1209   // Set BoundingBox to stage size if not already set.
1210   Rect<int> boundingBox;
1211   mDecorator->GetBoundingBox( boundingBox );
1212
1213   if( boundingBox.IsEmpty() )
1214   {
1215     Vector2 stageSize = Dali::Stage::GetCurrent().GetSize();
1216     mDecorator->SetBoundingBox( Rect<int>( 0.0f, 0.0f, stageSize.width, stageSize.height ) );
1217   }
1218
1219   // Whether to flip the selection handles as soon as they cross.
1220   mDecorator->FlipSelectionHandlesOnCrossEnabled( true );
1221
1222   // Set the default scroll speed.
1223   mDecorator->SetScrollSpeed( DEFAULT_SCROLL_SPEED );
1224
1225   // Fill-parent area by default
1226   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
1227   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
1228   self.OnStageSignal().Connect( this, &TextEditor::OnStageConnect );
1229
1230   // Creates an extra control to be used as stencil buffer.
1231   mStencil = Control::New();
1232   mStencil.SetAnchorPoint( AnchorPoint::TOP_LEFT );
1233   mStencil.SetParentOrigin( ParentOrigin::TOP_LEFT );
1234
1235   // Creates a background visual. Even if the color is transparent it updates the stencil.
1236   mStencil.SetProperty( Toolkit::Control::Property::BACKGROUND,
1237                         Property::Map().Add( Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR ).
1238                         Add( ColorVisual::Property::MIX_COLOR, Color::TRANSPARENT ) );
1239
1240   // Enable the clipping property.
1241   mStencil.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
1242   mStencil.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
1243
1244   self.Add( mStencil );
1245 }
1246
1247 void TextEditor::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange::Type change )
1248 {
1249   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange\n");
1250
1251   switch ( change )
1252   {
1253     case StyleChange::DEFAULT_FONT_CHANGE:
1254     {
1255       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnStyleChange DEFAULT_FONT_CHANGE\n");
1256       const std::string& newFont = GetImpl( styleManager ).GetDefaultFontFamily();
1257       // Property system did not set the font so should update it.
1258       mController->UpdateAfterFontChange( newFont );
1259       RelayoutRequest();
1260       break;
1261     }
1262
1263     case StyleChange::DEFAULT_FONT_SIZE_CHANGE:
1264     {
1265       GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
1266       RelayoutRequest();
1267       break;
1268     }
1269     case StyleChange::THEME_CHANGE:
1270     {
1271       // Nothing to do, let control base class handle this
1272       break;
1273     }
1274   }
1275
1276   // Up call to Control
1277   Control::OnStyleChange( styleManager, change );
1278 }
1279
1280 Vector3 TextEditor::GetNaturalSize()
1281 {
1282   Extents padding;
1283   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1284
1285   Vector3 naturalSize = mController->GetNaturalSize();
1286   naturalSize.width += ( padding.start + padding.end );
1287   naturalSize.height += ( padding.top + padding.bottom );
1288
1289   return naturalSize;
1290 }
1291
1292 float TextEditor::GetHeightForWidth( float width )
1293 {
1294   Extents padding;
1295   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1296   return mController->GetHeightForWidth( width ) + padding.top + padding.bottom;
1297 }
1298
1299 void TextEditor::OnRelayout( const Vector2& size, RelayoutContainer& container )
1300 {
1301   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor OnRelayout\n");
1302
1303   Actor self = Self();
1304
1305   Extents padding;
1306   padding = self.GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1307
1308   Vector2 contentSize( size.x - ( padding.start + padding.end ), size.y - ( padding.top + padding.bottom ) );
1309
1310   // Support Right-To-Left of padding
1311   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( self.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
1312   if( Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection )
1313   {
1314     std::swap( padding.start, padding.end );
1315   }
1316
1317   if( mStencil )
1318   {
1319     mStencil.SetPosition( padding.start, padding.top );
1320   }
1321   if( mActiveLayer )
1322   {
1323     mActiveLayer.SetPosition( padding.start, padding.top );
1324   }
1325
1326   const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize );
1327
1328   if( ( Text::Controller::NONE_UPDATED != updateTextType ) ||
1329       !mRenderer )
1330   {
1331     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnRelayout %p Displaying new contents\n", mController.Get() );
1332
1333     if( mDecorator &&
1334         ( Text::Controller::NONE_UPDATED != ( Text::Controller::DECORATOR_UPDATED & updateTextType ) ) )
1335     {
1336       mDecorator->Relayout( size );
1337     }
1338
1339     if( !mRenderer )
1340     {
1341       mRenderer = Backend::Get().NewRenderer( mRenderingBackend );
1342     }
1343
1344     RenderText( updateTextType );
1345
1346   }
1347
1348   // The text-editor emits signals when the input style changes. These changes of style are
1349   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1350   // can't be emitted during the size negotiation as the callbacks may update the UI.
1351   // The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
1352   if( !mController->IsInputStyleChangedSignalsQueueEmpty() )
1353   {
1354     if( Adaptor::IsAvailable() )
1355     {
1356       Adaptor& adaptor = Adaptor::Get();
1357
1358       if( NULL == mIdleCallback )
1359       {
1360         // @note: The callback manager takes the ownership of the callback object.
1361         mIdleCallback = MakeCallback( this, &TextEditor::OnIdleSignal );
1362         adaptor.AddIdle( mIdleCallback );
1363       }
1364     }
1365   }
1366 }
1367
1368 void TextEditor::RenderText( Text::Controller::UpdateTextType updateTextType )
1369 {
1370   Actor renderableActor;
1371
1372   if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) )
1373   {
1374     if( mRenderer )
1375     {
1376       Dali::Toolkit::TextEditor handle = Dali::Toolkit::TextEditor( GetOwner() );
1377
1378       renderableActor = mRenderer->Render( mController->GetView(),
1379                                            handle,
1380                                            Property::INVALID_INDEX, // Animatable property not supported
1381                                            mAlignmentOffset,
1382                                            DepthIndex::CONTENT );
1383     }
1384
1385     if( renderableActor != mRenderableActor )
1386     {
1387       UnparentAndReset( mRenderableActor );
1388       mRenderableActor = renderableActor;
1389     }
1390   }
1391
1392   if( mRenderableActor )
1393   {
1394     // Make sure the actors are parented correctly with/without clipping
1395     Actor self = mStencil ? mStencil : Self();
1396
1397     for( std::vector<Actor>::iterator it = mClippingDecorationActors.begin(),
1398            endIt = mClippingDecorationActors.end();
1399          it != endIt;
1400          ++it )
1401     {
1402       self.Add( *it );
1403       it->LowerToBottom();
1404     }
1405     mClippingDecorationActors.clear();
1406
1407     self.Add( mRenderableActor );
1408
1409     ApplyScrollPosition();
1410   }
1411   UpdateScrollBar();
1412 }
1413
1414 void TextEditor::OnKeyInputFocusGained()
1415 {
1416   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnKeyInputFocusGained %p\n", mController.Get() );
1417
1418   mImfManager.StatusChangedSignal().Connect( this, &TextEditor::KeyboardStatusChanged );
1419
1420   mImfManager.EventReceivedSignal().Connect( this, &TextEditor::OnImfEvent );
1421
1422   // Notify that the text editing start.
1423   mImfManager.Activate();
1424
1425   // When window gain lost focus, the imf manager is deactivated. Thus when window gain focus again, the imf manager must be activated.
1426   mImfManager.SetRestoreAfterFocusLost( true );
1427
1428    ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
1429
1430    if ( notifier )
1431    {
1432       notifier.ContentSelectedSignal().Connect( this, &TextEditor::OnClipboardTextSelected );
1433    }
1434
1435   mController->KeyboardFocusGainEvent(); // Called in the case of no virtual keyboard to trigger this event
1436
1437   EmitKeyInputFocusSignal( true ); // Calls back into the Control hence done last.
1438 }
1439
1440 void TextEditor::OnKeyInputFocusLost()
1441 {
1442   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor:OnKeyInputFocusLost %p\n", mController.Get() );
1443
1444   mImfManager.StatusChangedSignal().Disconnect( this, &TextEditor::KeyboardStatusChanged );
1445
1446   // The text editing is finished. Therefore the imf manager don't have restore activation.
1447   mImfManager.SetRestoreAfterFocusLost( false );
1448
1449   // Notify that the text editing finish.
1450   mImfManager.Deactivate();
1451
1452   mImfManager.EventReceivedSignal().Disconnect( this, &TextEditor::OnImfEvent );
1453
1454   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
1455
1456   if ( notifier )
1457   {
1458     notifier.ContentSelectedSignal().Disconnect( this, &TextEditor::OnClipboardTextSelected );
1459   }
1460
1461   mController->KeyboardFocusLostEvent();
1462
1463   EmitKeyInputFocusSignal( false ); // Calls back into the Control hence done last.
1464 }
1465
1466 void TextEditor::OnTap( const TapGesture& gesture )
1467 {
1468   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnTap %p\n", mController.Get() );
1469
1470   mImfManager.Activate();
1471
1472   // Deliver the tap before the focus event to controller; this allows us to detect when focus is gained due to tap-gestures
1473   Extents padding;
1474   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1475   mController->TapEvent( gesture.numberOfTaps, gesture.localPoint.x - padding.start, gesture.localPoint.y - padding.top );
1476
1477   SetKeyInputFocus();
1478 }
1479
1480 void TextEditor::OnPan( const PanGesture& gesture )
1481 {
1482   mController->PanEvent( gesture.state, gesture.displacement );
1483 }
1484
1485 void TextEditor::OnLongPress( const LongPressGesture& gesture )
1486 {
1487   mImfManager.Activate();
1488
1489   Extents padding;
1490   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
1491   mController->LongPressEvent( gesture.state, gesture.localPoint.x - padding.start, gesture.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.keyCode );
1499
1500   if( Dali::DALI_KEY_ESCAPE == event.keyCode && mController->ShouldClearFocusOnEscape() )
1501   {
1502     // Make sure ClearKeyInputFocus when only key is up
1503     if( event.state == 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   // Nothing to do as TextEditor doesn't emit a max length reached signal.
1528 }
1529
1530 void TextEditor::InputStyleChanged( Text::InputStyle::Mask inputStyleMask )
1531 {
1532   Dali::Toolkit::TextEditor handle( GetOwner() );
1533
1534   Toolkit::TextEditor::InputStyle::Mask editorInputStyleMask = Toolkit::TextEditor::InputStyle::NONE;
1535
1536   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_COLOR ) )
1537   {
1538     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::COLOR );
1539   }
1540   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_FAMILY ) )
1541   {
1542     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_FAMILY );
1543   }
1544   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_POINT_SIZE ) )
1545   {
1546     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::POINT_SIZE );
1547   }
1548   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_WEIGHT ) )
1549   {
1550     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1551   }
1552   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_WIDTH ) )
1553   {
1554     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1555   }
1556   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_FONT_SLANT ) )
1557   {
1558     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::FONT_STYLE );
1559   }
1560   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_LINE_SPACING ) )
1561   {
1562     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::LINE_SPACING );
1563   }
1564   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_UNDERLINE ) )
1565   {
1566     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::UNDERLINE );
1567   }
1568   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_SHADOW ) )
1569   {
1570     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::SHADOW );
1571   }
1572   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_EMBOSS ) )
1573   {
1574     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::EMBOSS );
1575   }
1576   if( InputStyle::NONE != static_cast<InputStyle::Mask>( inputStyleMask & InputStyle::INPUT_OUTLINE ) )
1577   {
1578     editorInputStyleMask = static_cast<Toolkit::TextEditor::InputStyle::Mask>( editorInputStyleMask | Toolkit::TextEditor::InputStyle::OUTLINE );
1579   }
1580
1581   mInputStyleChangedSignal.Emit( handle, editorInputStyleMask );
1582 }
1583
1584 void TextEditor::AddDecoration( Actor& actor, bool needsClipping )
1585 {
1586   if( actor )
1587   {
1588     if( needsClipping )
1589     {
1590       mClippingDecorationActors.push_back( actor );
1591     }
1592     else
1593     {
1594       actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
1595       actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
1596       Self().Add( actor );
1597       mActiveLayer = actor;
1598     }
1599   }
1600 }
1601
1602 void TextEditor::UpdateScrollBar()
1603 {
1604   using namespace Dali;
1605
1606   float scrollPosition;
1607   float controlSize;
1608   float layoutSize;
1609   bool latestScrolled;
1610
1611   if ( !mScrollBarEnabled )
1612   {
1613     return;
1614   }
1615   latestScrolled = mController->GetTextScrollInfo( scrollPosition, controlSize, layoutSize );
1616   if ( !latestScrolled || controlSize > layoutSize)
1617   {
1618     return;
1619   }
1620
1621   CustomActor self = Self();
1622   if( !mScrollBar )
1623   {
1624     mScrollBar = Toolkit::ScrollBar::New( Toolkit::ScrollBar::Vertical );
1625     mScrollBar.SetIndicatorHeightPolicy( Toolkit::ScrollBar::Variable );
1626     mScrollBar.SetParentOrigin( ParentOrigin::TOP_RIGHT );
1627     mScrollBar.SetAnchorPoint( AnchorPoint::TOP_RIGHT );
1628     mScrollBar.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
1629     mScrollBar.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
1630
1631     // Register the scroll position property
1632     Property::Index propertyScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION, scrollPosition );
1633     // Register the minimum scroll position property
1634     Property::Index propertyMinScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION_MIN, 0.0f );
1635     // Register the maximum scroll position property
1636     Property::Index propertyMaxScrollPosition = self.RegisterProperty( SCROLL_BAR_POSITION_MAX, (layoutSize - controlSize) );
1637     // Register the scroll content size property
1638     Property::Index propertyScrollContentSize = self.RegisterProperty( SCROLL_BAR_CONTENT_SIZE, layoutSize );
1639
1640     mScrollBar.SetScrollPropertySource(self, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
1641
1642     // Set style name of ScrollBar for styling
1643     mScrollBar.SetStyleName("TextEditorScrollBar");
1644     Toolkit::Control scrollIndicator = Toolkit::Control::DownCast( mScrollBar.GetScrollIndicator() );
1645     if( scrollIndicator )
1646     {
1647       // Set style name of ScrollBarIndicator for styling
1648       scrollIndicator.SetStyleName("TextEditorScrollBarIndicator");
1649     }
1650
1651     self.Add( mScrollBar );
1652   }
1653   else
1654   {
1655     Property::Index propertyScrollPosition = self.GetPropertyIndex( SCROLL_BAR_POSITION );
1656     Property::Index propertyMaxScrollPosition = self.GetPropertyIndex( SCROLL_BAR_POSITION_MAX );
1657     Property::Index propertyScrollContentSize = self.GetPropertyIndex( SCROLL_BAR_CONTENT_SIZE );
1658
1659     self.SetProperty( propertyScrollPosition, scrollPosition );
1660     self.SetProperty( propertyMaxScrollPosition, (layoutSize - controlSize) );
1661     self.SetProperty( propertyScrollContentSize, layoutSize );
1662   }
1663
1664   // If scrolling is not started, start scrolling and emit ScrollStateChangedSignal
1665   if( !mScrollStarted )
1666   {
1667     mScrollStarted = true;
1668     Dali::Toolkit::TextEditor handle( GetOwner() );
1669     mScrollStateChangedSignal.Emit( handle, Toolkit::TextEditor::Scroll::STARTED );
1670   }
1671
1672   Actor indicator = mScrollBar.GetScrollIndicator();
1673   if( mAnimation )
1674   {
1675     mAnimation.Stop(); // Cancel any animation
1676   }
1677   else
1678   {
1679     mAnimation = Animation::New( mAnimationPeriod.durationSeconds );
1680   }
1681   indicator.SetOpacity(1.0f);
1682   mAnimation.AnimateTo( Property( indicator, Actor::Property::COLOR_ALPHA ), 0.0f, AlphaFunction::EASE_IN, mAnimationPeriod );
1683   mAnimation.Play();
1684   mAnimation.FinishedSignal().Connect( this, &TextEditor::OnScrollIndicatorAnimationFinished );
1685 }
1686
1687 void TextEditor::OnScrollIndicatorAnimationFinished( Animation& animation )
1688 {
1689   // If animation is successfully ended, then emit ScrollStateChangedSignal
1690   if( animation.GetCurrentProgress() == 0.0f )
1691   {
1692     mScrollStarted = false;
1693     Dali::Toolkit::TextEditor handle( GetOwner() );
1694     mScrollStateChangedSignal.Emit( handle, Toolkit::TextEditor::Scroll::FINISHED );
1695   }
1696 }
1697
1698 void TextEditor::OnStageConnect( Dali::Actor actor )
1699 {
1700   if ( mHasBeenStaged )
1701   {
1702     RenderText( static_cast<Text::Controller::UpdateTextType>( Text::Controller::MODEL_UPDATED | Text::Controller::DECORATOR_UPDATED ) );
1703   }
1704   else
1705   {
1706     mHasBeenStaged = true;
1707   }
1708 }
1709
1710 ImfManager::ImfCallbackData TextEditor::OnImfEvent( Dali::ImfManager& imfManager, const ImfManager::ImfEventData& imfEvent )
1711 {
1712   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::OnImfEvent %p eventName %d\n", mController.Get(), imfEvent.eventName );
1713   return mController->OnImfEvent( imfManager, imfEvent );
1714 }
1715
1716 void TextEditor::GetHandleImagePropertyValue(  Property::Value& value, Text::HandleType handleType, Text::HandleImageType handleImageType )
1717 {
1718   if( mDecorator )
1719   {
1720     ResourceImage image = ResourceImage::DownCast( mDecorator->GetHandleImage( handleType, handleImageType ) );
1721
1722     if ( image )
1723     {
1724       Property::Map map;
1725       Scripting::CreatePropertyMap( image, map );
1726       value = map;
1727     }
1728   }
1729 }
1730
1731 void TextEditor::OnClipboardTextSelected( ClipboardEventNotifier& clipboard )
1732 {
1733   mController->PasteClipboardItemEvent();
1734 }
1735
1736 void TextEditor::KeyboardStatusChanged(bool keyboardShown)
1737 {
1738   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextEditor::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown );
1739
1740   // Just hide the grab handle when keyboard is hidden.
1741   if (!keyboardShown )
1742   {
1743     mController->KeyboardFocusLostEvent();
1744   }
1745   else
1746   {
1747     mController->KeyboardFocusGainEvent(); // Initially called by OnKeyInputFocusGained
1748   }
1749 }
1750
1751 void TextEditor::OnStageConnection( int depth )
1752 {
1753   // Sets the depth to the visuals inside the text's decorator.
1754   mDecorator->SetTextDepth( depth );
1755
1756   // The depth of the text renderer is set in the RenderText() called from OnRelayout().
1757
1758   // Call the Control::OnStageConnection() to set the depth of the background.
1759   Control::OnStageConnection( depth );
1760 }
1761
1762 bool TextEditor::OnTouched( Actor actor, const TouchData& touch )
1763 {
1764   return true;
1765 }
1766
1767 void TextEditor::OnIdleSignal()
1768 {
1769   // Emits the change of input style signals.
1770   mController->ProcessInputStyleChangedSignals();
1771
1772   // Set the pointer to null as the callback manager deletes the callback after execute it.
1773   mIdleCallback = NULL;
1774 }
1775
1776 void TextEditor::ApplyScrollPosition()
1777 {
1778   const Vector2& scrollOffset = mController->GetTextModel()->GetScrollPosition();
1779   float scrollAmount = 0.0f;
1780
1781   if ( mScrollAnimationEnabled )
1782   {
1783     scrollAmount = mController->GetScrollAmountByUserInput();
1784   }
1785   if ( mTextVerticalScroller )
1786   {
1787     mTextVerticalScroller->CheckStartAnimation( mRenderableActor, scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount, scrollAmount );
1788   }
1789   else if ( Equals( scrollAmount, 0.0f, Math::MACHINE_EPSILON_1 ))
1790   {
1791     mRenderableActor.SetPosition( scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount );
1792   }
1793   else
1794   {
1795     mTextVerticalScroller = Text::TextVerticalScroller::New();
1796     if ( !Equals( mScrollAnimationDuration, 0.0f, Math::MACHINE_EPSILON_1 ))
1797     {
1798       mTextVerticalScroller->SetDuration( mScrollAnimationDuration );
1799     }
1800     mTextVerticalScroller->CheckStartAnimation( mRenderableActor, scrollOffset.x + mAlignmentOffset, scrollOffset.y - scrollAmount, scrollAmount );
1801   }
1802 }
1803
1804 TextEditor::TextEditor()
1805 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
1806   mAnimationPeriod( 0.0f, 0.0f ),
1807   mIdleCallback( NULL ),
1808   mAlignmentOffset( 0.f ),
1809   mScrollAnimationDuration( 0.f ),
1810   mLineSpacing( 0.f ),
1811   mRenderingBackend( DEFAULT_RENDERING_BACKEND ),
1812   mHasBeenStaged( false ),
1813   mScrollAnimationEnabled( false ),
1814   mScrollBarEnabled( false ),
1815   mScrollStarted( false )
1816 {
1817 }
1818
1819 TextEditor::~TextEditor()
1820 {
1821   UnparentAndReset( mStencil );
1822
1823   if( ( NULL != mIdleCallback ) && Adaptor::IsAvailable() )
1824   {
1825     // Removes the callback from the callback manager in case the text-editor is destroyed before the callback is executed.
1826     Adaptor::Get().RemoveIdle( mIdleCallback );
1827   }
1828 }
1829
1830 } // namespace Internal
1831
1832 } // namespace Toolkit
1833
1834 } // namespace Dali