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