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