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