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