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