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