dali-toolkit/internal/controls/text-controls/text-field-impl.cpp

   1 /*
   2  * Copyright (c) 2015 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 <string>
  23 #include <cstring>
  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/public-api/object/type-registry.h>
  28 #include <dali/public-api/object/type-registry-helper.h>
  29 #include <dali/public-api/scripting/scripting.h>
  30 #include <dali/integration-api/debug.h>
  31 #include <dali/public-api/adaptor-framework/virtual-keyboard.h>
  32
  33 // INTERNAL INCLUDES
  34 #include <dali-toolkit/public-api/text/rendering-backend.h>
  35 #include <dali-toolkit/internal/text/layouts/layout-engine.h>
  36 #include <dali-toolkit/internal/text/rendering/text-backend.h>
  37 #include <dali-toolkit/internal/styling/style-manager-impl.h>
  38
  39 using namespace Dali::Toolkit::Text;
  40
  41 namespace Dali
  42 {
  43
  44 namespace Toolkit
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace
  51 {
  52   const unsigned int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
  53 }
  54
  55 namespace
  56 {
  57
  58 const Scripting::StringEnum< Toolkit::Text::LayoutEngine::HorizontalAlignment > HORIZONTAL_ALIGNMENT_STRING_TABLE[] =
  59 {
  60   { "BEGIN",  Toolkit::Text::LayoutEngine::HORIZONTAL_ALIGN_BEGIN  },
  61   { "CENTER", Toolkit::Text::LayoutEngine::HORIZONTAL_ALIGN_CENTER },
  62   { "END",    Toolkit::Text::LayoutEngine::HORIZONTAL_ALIGN_END    },
  63 };
  64 const unsigned int HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE ) / sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE[0] );
  65
  66 const Scripting::StringEnum< Toolkit::Text::LayoutEngine::VerticalAlignment > VERTICAL_ALIGNMENT_STRING_TABLE[] =
  67 {
  68   { "TOP",    Toolkit::Text::LayoutEngine::VERTICAL_ALIGN_TOP    },
  69   { "CENTER", Toolkit::Text::LayoutEngine::VERTICAL_ALIGN_CENTER },
  70   { "BOTTOM", Toolkit::Text::LayoutEngine::VERTICAL_ALIGN_BOTTOM },
  71 };
  72 const unsigned int VERTICAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof( VERTICAL_ALIGNMENT_STRING_TABLE ) / sizeof( VERTICAL_ALIGNMENT_STRING_TABLE[0] );
  73
  74 // Type registration
  75 BaseHandle Create()
  76 {
  77   return Toolkit::TextField::New();
  78 }
  79
  80 // Setup properties, signals and actions using the type-registry.
  81 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TextField, Toolkit::Control, Create );
  82
  83 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "rendering-backend",                    INTEGER,   RENDERING_BACKEND                    )
  84 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "placeholder-text",                     STRING,    PLACEHOLDER_TEXT                     )
  85 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "text",                                 STRING,    TEXT                                 )
  86 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "font-family",                          STRING,    FONT_FAMILY                          )
  87 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "font-style",                           STRING,    FONT_STYLE                           )
  88 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "point-size",                           FLOAT,     POINT_SIZE                           )
  89 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "max-length",                           INTEGER,   MAX_LENGTH                           )
  90 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "exceed-policy",                        INTEGER,   EXCEED_POLICY                        )
  91 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "horizontal-alignment",                 STRING,    HORIZONTAL_ALIGNMENT                 )
  92 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "vertical-alignment",                   STRING,    VERTICAL_ALIGNMENT                   )
  93 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "text-color",                           VECTOR4,   TEXT_COLOR                           )
  94 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadow-offset",                        VECTOR2,   SHADOW_OFFSET                        )
  95 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "shadow-color",                         VECTOR4,   SHADOW_COLOR                         )
  96 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "primary-cursor-color",                 VECTOR4,   PRIMARY_CURSOR_COLOR                 )
  97 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "secondary-cursor-color",               VECTOR4,   SECONDARY_CURSOR_COLOR               )
  98 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "enable-cursor-blink",                  BOOLEAN,   ENABLE_CURSOR_BLINK                  )
  99 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursor-blink-interval",                FLOAT,     CURSOR_BLINK_INTERVAL                )
 100 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "cursor-blink-duration",                FLOAT,     CURSOR_BLINK_DURATION                )
 101 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grab-handle-image",                    STRING,    GRAB_HANDLE_IMAGE                    )
 102 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "grab-handle-pressed-image",            VECTOR4,   GRAB_HANDLE_PRESSED_IMAGE            )
 103 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "scroll-threshold",                     FLOAT,     SCROLL_THRESHOLD                     )
 104 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "scroll-speed",                         FLOAT,     SCROLL_SPEED                         )
 105 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-image-left",          STRING,    SELECTION_HANDLE_IMAGE_LEFT          )
 106 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-image-right",         STRING,    SELECTION_HANDLE_IMAGE_RIGHT         )
 107 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-pressed-image-left",  STRING,    SELECTION_HANDLE_PRESSED_IMAGE_LEFT  )
 108 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-handle-pressed-image-right", STRING,    SELECTION_HANDLE_PRESSED_IMAGE_RIGHT )
 109 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "selection-highlight-color",            STRING,    SELECTION_HIGHLIGHT_COLOR            )
 110 DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "decoration-bounding-box",              RECTANGLE, DECORATION_BOUNDING_BOX              )
 111
 112 DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "max-length-reached", SIGNAL_MAX_LENGTH_REACHED )
 113
 114 DALI_TYPE_REGISTRATION_END()
 115
 116 } // namespace
 117
 118 Toolkit::TextField TextField::New()
 119 {
 120   // Create the implementation, temporarily owned by this handle on stack
 121   IntrusivePtr< TextField > impl = new TextField();
 122
 123   // Pass ownership to CustomActor handle
 124   Toolkit::TextField handle( *impl );
 125
 126   // Second-phase init of the implementation
 127   // This can only be done after the CustomActor connection has been made...
 128   impl->Initialize();
 129
 130   return handle;
 131 }
 132
 133 void TextField::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 134 {
 135   Toolkit::TextField textField = Toolkit::TextField::DownCast( Dali::BaseHandle( object ) );
 136
 137   if( textField )
 138   {
 139     TextField& impl( GetImpl( textField ) );
 140
 141     switch( index )
 142     {
 143       case Toolkit::TextField::Property::RENDERING_BACKEND:
 144       {
 145         int backend = value.Get< int >();
 146
 147         if( impl.mRenderingBackend != backend )
 148         {
 149           impl.mRenderingBackend = backend;
 150           impl.mRenderer.Reset();
 151         }
 152         break;
 153       }
 154       case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
 155       {
 156         if( impl.mController )
 157         {
 158           //impl.mController->SetPlaceholderText( value.Get< std::string >() ); TODO
 159         }
 160         break;
 161       }
 162       case Toolkit::TextField::Property::TEXT:
 163       {
 164         if( impl.mController )
 165         {
 166           impl.mController->SetText( value.Get< std::string >() );
 167         }
 168         break;
 169       }
 170       case Toolkit::TextField::Property::FONT_FAMILY:
 171       {
 172         if( impl.mController )
 173         {
 174           std::string fontFamily = value.Get< std::string >();
 175
 176           if( impl.mController->GetDefaultFontFamily() != fontFamily )
 177           {
 178             impl.mController->SetDefaultFontFamily( fontFamily );
 179             impl.RequestTextRelayout();
 180           }
 181         }
 182         break;
 183       }
 184       case Toolkit::TextField::Property::FONT_STYLE:
 185       {
 186         if( impl.mController )
 187         {
 188           std::string fontStyle = value.Get< std::string >();
 189
 190           if( impl.mController->GetDefaultFontStyle() != fontStyle )
 191           {
 192             impl.mController->SetDefaultFontStyle( fontStyle );
 193             impl.RequestTextRelayout();
 194           }
 195         }
 196         break;
 197       }
 198       case Toolkit::TextField::Property::POINT_SIZE:
 199       {
 200         if( impl.mController )
 201         {
 202           float pointSize = value.Get< float >();
 203
 204           if( !Equals( impl.mController->GetDefaultPointSize(), pointSize ) )
 205           {
 206             impl.mController->SetDefaultPointSize( pointSize );
 207             impl.RequestTextRelayout();
 208           }
 209         }
 210         break;
 211       }
 212       case Toolkit::TextField::Property::EXCEED_POLICY:
 213       {
 214         impl.mExceedPolicy = value.Get< int >();
 215         break;
 216       }
 217       case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
 218       {
 219         LayoutEngine& engine = impl.mController->GetLayoutEngine();
 220         const LayoutEngine::HorizontalAlignment alignment = Scripting::GetEnumeration< Toolkit::Text::LayoutEngine::HorizontalAlignment >( value.Get< std::string >().c_str(),
 221                                                                                                                                            HORIZONTAL_ALIGNMENT_STRING_TABLE,
 222                                                                                                                                            HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT );
 223
 224         if( engine.GetHorizontalAlignment() != alignment )
 225         {
 226           engine.SetHorizontalAlignment( alignment );
 227           impl.RequestTextRelayout();
 228         }
 229         break;
 230       }
 231       case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
 232       {
 233         LayoutEngine& engine = impl.mController->GetLayoutEngine();
 234         const LayoutEngine::VerticalAlignment alignment = Scripting::GetEnumeration< Toolkit::Text::LayoutEngine::VerticalAlignment >( value.Get< std::string >().c_str(),
 235                                                                                                                                        VERTICAL_ALIGNMENT_STRING_TABLE,
 236                                                                                                                                        VERTICAL_ALIGNMENT_STRING_TABLE_COUNT );
 237
 238         if( engine.GetVerticalAlignment() != alignment )
 239         {
 240           engine.SetVerticalAlignment( alignment );
 241           impl.RequestTextRelayout();
 242         }
 243         break;
 244       }
 245       case Toolkit::TextField::Property::TEXT_COLOR:
 246       {
 247         if ( impl.mController )
 248         {
 249           Vector4 textColor = value.Get< Vector4 >();
 250           if ( impl.mController->GetTextColor() != textColor )
 251           {
 252             impl.mController->SetTextColor( textColor );
 253             impl.RequestTextRelayout();
 254           }
 255         }
 256         break;
 257       }
 258       case Toolkit::TextField::Property::SHADOW_OFFSET:
 259       {
 260         if( impl.mController )
 261         {
 262           Vector2 shadowOffset = value.Get< Vector2 >();
 263           if ( impl.mController->GetShadowOffset() != shadowOffset )
 264           {
 265             impl.mController->SetShadowOffset( shadowOffset );
 266             impl.RequestTextRelayout();
 267           }
 268         }
 269         break;
 270       }
 271       case Toolkit::TextField::Property::SHADOW_COLOR:
 272       {
 273         if( impl.mController )
 274         {
 275           Vector4 shadowColor = value.Get< Vector4 >();
 276           if ( impl.mController->GetShadowColor() != shadowColor )
 277           {
 278             impl.mController->SetShadowColor( shadowColor );
 279             impl.RequestTextRelayout();
 280           }
 281         }
 282         break;
 283       }
 284       case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
 285       {
 286         if( impl.mDecorator )
 287         {
 288           impl.mDecorator->SetColor( PRIMARY_CURSOR, value.Get< Vector4 >() );
 289         }
 290         break;
 291       }
 292       case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
 293       {
 294         if( impl.mDecorator )
 295         {
 296           impl.mDecorator->SetColor( SECONDARY_CURSOR, value.Get< Vector4 >() );
 297         }
 298         break;
 299       }
 300       case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
 301       {
 302         if( impl.mController )
 303         {
 304           impl.mController->SetEnableCursorBlink( value.Get< bool >() );
 305         }
 306         break;
 307       }
 308       case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
 309       {
 310         if( impl.mDecorator )
 311         {
 312           impl.mDecorator->SetCursorBlinkInterval( value.Get< float >() );
 313         }
 314         break;
 315       }
 316       case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
 317       {
 318         if( impl.mDecorator )
 319         {
 320           impl.mDecorator->SetCursorBlinkDuration( value.Get< float >() );
 321         }
 322         break;
 323       }
 324       case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
 325       {
 326         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 327
 328         if( impl.mDecorator )
 329         {
 330           impl.mDecorator->SetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_RELEASED, image );
 331         }
 332         break;
 333       }
 334       case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
 335       {
 336         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 337
 338         if( impl.mDecorator )
 339         {
 340           impl.mDecorator->SetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_PRESSED, image );
 341         }
 342         break;
 343       }
 344       case Toolkit::TextField::Property::SCROLL_THRESHOLD:
 345       {
 346         float threshold = value.Get< float >();
 347
 348         if( impl.mDecorator )
 349         {
 350           impl.mDecorator->SetScrollThreshold( threshold );
 351         }
 352         break;
 353       }
 354       case Toolkit::TextField::Property::SCROLL_SPEED:
 355       {
 356         float speed = value.Get< float >();
 357
 358         if( impl.mDecorator )
 359         {
 360           impl.mDecorator->SetScrollSpeed( speed );
 361         }
 362         break;
 363       }
 364       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
 365       {
 366         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 367
 368         if( impl.mDecorator )
 369         {
 370           impl.mDecorator->SetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, image );
 371         }
 372         break;
 373       }
 374       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 375       {
 376         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 377
 378         if( impl.mDecorator )
 379         {
 380           impl.mDecorator->SetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED, image );
 381         }
 382         break;
 383       }
 384       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 385       {
 386         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 387
 388         if( impl.mDecorator )
 389         {
 390           impl.mDecorator->SetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, image );
 391         }
 392         break;
 393       }
 394       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 395       {
 396         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 397
 398         if( impl.mDecorator )
 399         {
 400           impl.mDecorator->SetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED, image );
 401         }
 402         break;
 403       }
 404       case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
 405       {
 406         Vector4 color = value.Get< Vector4 >();
 407
 408         if( impl.mDecorator )
 409         {
 410           impl.mDecorator->SetHighlightColor( color );
 411         }
 412         break;
 413       }
 414       case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
 415       {
 416         if( impl.mDecorator )
 417         {
 418           impl.mDecorator->SetBoundingBox( value.Get< Rect<int> >() );
 419         }
 420         break;
 421       }
 422       case Toolkit::TextField::Property::MAX_LENGTH:
 423       {
 424         if( impl.mController )
 425         {
 426           impl.mController->SetMaximumNumberOfCharacters( value.Get< int >() );
 427         }
 428         break;
 429       }
 430     } // switch
 431   } // textfield
 432 }
 433
 434 Property::Value TextField::GetProperty( BaseObject* object, Property::Index index )
 435 {
 436   Property::Value value;
 437
 438   Toolkit::TextField textField = Toolkit::TextField::DownCast( Dali::BaseHandle( object ) );
 439
 440   if( textField )
 441   {
 442     TextField& impl( GetImpl( textField ) );
 443
 444     switch( index )
 445     {
 446       case Toolkit::TextField::Property::RENDERING_BACKEND:
 447       {
 448         value = impl.mRenderingBackend;
 449         break;
 450       }
 451       case Toolkit::TextField::Property::PLACEHOLDER_TEXT:
 452       {
 453         if( impl.mController )
 454         {
 455           std::string text;
 456           impl.mController->GetPlaceholderText( text );
 457           value = text;
 458         }
 459         break;
 460       }
 461       case Toolkit::TextField::Property::TEXT:
 462       {
 463         if( impl.mController )
 464         {
 465           std::string text;
 466           impl.mController->GetText( text );
 467           value = text;
 468         }
 469         break;
 470       }
 471       case Toolkit::TextField::Property::EXCEED_POLICY:
 472       {
 473         value = impl.mExceedPolicy;
 474         break;
 475       }
 476       case Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT:
 477       {
 478         if( impl.mController )
 479         {
 480           value = std::string( Scripting::GetEnumerationName< Toolkit::Text::LayoutEngine::HorizontalAlignment >( impl.mController->GetLayoutEngine().GetHorizontalAlignment(),
 481                                                                                                                   HORIZONTAL_ALIGNMENT_STRING_TABLE,
 482                                                                                                                   HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT ) );
 483         }
 484         break;
 485       }
 486       case Toolkit::TextField::Property::VERTICAL_ALIGNMENT:
 487       {
 488         if( impl.mController )
 489         {
 490           value = std::string( Scripting::GetEnumerationName< Toolkit::Text::LayoutEngine::VerticalAlignment >( impl.mController->GetLayoutEngine().GetVerticalAlignment(),
 491                                                                                                                   VERTICAL_ALIGNMENT_STRING_TABLE,
 492                                                                                                                   VERTICAL_ALIGNMENT_STRING_TABLE_COUNT ) );
 493         }
 494         break;
 495       }
 496       case Toolkit::TextField::Property::TEXT_COLOR:
 497       {
 498         if ( impl.mController )
 499         {
 500           value = impl.mController->GetTextColor();
 501         }
 502         break;
 503       }
 504       case Toolkit::TextField::Property::SHADOW_OFFSET:
 505       {
 506         if ( impl.mController )
 507         {
 508           value = impl.mController->GetShadowOffset();
 509         }
 510         break;
 511       }
 512       case Toolkit::TextField::Property::SHADOW_COLOR:
 513       {
 514         if ( impl.mController )
 515         {
 516           value = impl.mController->GetShadowColor();
 517         }
 518         break;
 519       }
 520       case Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR:
 521       {
 522         if( impl.mDecorator )
 523         {
 524           value = impl.mDecorator->GetColor( PRIMARY_CURSOR );
 525         }
 526         break;
 527       }
 528       case Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR:
 529       {
 530         if( impl.mDecorator )
 531         {
 532           value = impl.mDecorator->GetColor( SECONDARY_CURSOR );
 533         }
 534         break;
 535       }
 536       case Toolkit::TextField::Property::ENABLE_CURSOR_BLINK:
 537       {
 538         value = impl.mController->GetEnableCursorBlink();
 539         break;
 540       }
 541       case Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL:
 542       {
 543         if( impl.mDecorator )
 544         {
 545           value = impl.mDecorator->GetCursorBlinkInterval();
 546         }
 547         break;
 548       }
 549       case Toolkit::TextField::Property::CURSOR_BLINK_DURATION:
 550       {
 551         if( impl.mDecorator )
 552         {
 553           value = impl.mDecorator->GetCursorBlinkDuration();
 554         }
 555         break;
 556       }
 557       case Toolkit::TextField::Property::GRAB_HANDLE_IMAGE:
 558       {
 559         if( impl.mDecorator )
 560         {
 561           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_RELEASED ) );
 562           if( image )
 563           {
 564             value = image.GetUrl();
 565           }
 566         }
 567         break;
 568       }
 569       case Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE:
 570       {
 571         if( impl.mDecorator )
 572         {
 573           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_PRESSED ) );
 574           if( image )
 575           {
 576             value = image.GetUrl();
 577           }
 578         }
 579         break;
 580       }
 581       case Toolkit::TextField::Property::SCROLL_THRESHOLD:
 582       {
 583         if( impl.mDecorator )
 584         {
 585           value = impl.mDecorator->GetScrollThreshold();
 586         }
 587         break;
 588       }
 589       case Toolkit::TextField::Property::SCROLL_SPEED:
 590       {
 591         if( impl.mDecorator )
 592         {
 593           value = impl.mDecorator->GetScrollSpeed();
 594         }
 595         break;
 596       }
 597       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT:
 598       {
 599         if( impl.mDecorator )
 600         {
 601           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED ) );
 602           if( image )
 603           {
 604             value = image.GetUrl();
 605           }
 606         }
 607         break;
 608       }
 609       case Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 610       {
 611         if( impl.mDecorator )
 612         {
 613           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_RELEASED ) );
 614           if( image )
 615           {
 616             value = image.GetUrl();
 617           }
 618         }
 619         break;
 620       }
 621       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 622       {
 623         if( impl.mDecorator )
 624         {
 625           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( LEFT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED ) );
 626           if( image )
 627           {
 628             value = image.GetUrl();
 629           }
 630         }
 631         break;
 632       }
 633       case Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 634       {
 635         if( impl.mDecorator )
 636         {
 637           ResourceImage image = ResourceImage::DownCast( impl.mDecorator->GetHandleImage( RIGHT_SELECTION_HANDLE, HANDLE_IMAGE_PRESSED ) );
 638           if( image )
 639           {
 640             value = image.GetUrl();
 641           }
 642         }
 643         break;
 644       }
 645       case Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR:
 646       {
 647         if( impl.mDecorator )
 648         {
 649           value = impl.mDecorator->GetHighlightColor();
 650         }
 651         break;
 652       }
 653       case Toolkit::TextField::Property::DECORATION_BOUNDING_BOX:
 654       {
 655         if( impl.mDecorator )
 656         {
 657           value = impl.mDecorator->GetBoundingBox();
 658         }
 659         break;
 660       }
 661       case Toolkit::TextField::Property::MAX_LENGTH:
 662       {
 663         if( impl.mController )
 664         {
 665           value = impl.mController->GetMaximumNumberOfCharacters();
 666         }
 667         break;
 668       }
 669     } //switch
 670   }
 671
 672   return value;
 673 }
 674
 675 bool TextField::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 676 {
 677   Dali::BaseHandle handle( object );
 678
 679   bool connected( true );
 680   Toolkit::TextField field = Toolkit::TextField::DownCast( handle );
 681
 682   if( 0 == strcmp( signalName.c_str(), SIGNAL_MAX_LENGTH_REACHED ) )
 683   {
 684     field.MaxLengthReachedSignal().Connect( tracker, functor );
 685   }
 686   else
 687   {
 688     // signalName does not match any signal
 689     connected = false;
 690   }
 691
 692   return connected;
 693 }
 694
 695 Toolkit::TextField::MaxLengthReachedSignalType& TextField::MaxLengthReachedSignal()
 696 {
 697   return mMaxLengthReachedSignal;
 698 }
 699
 700 void TextField::OnInitialize()
 701 {
 702   Actor self = Self();
 703
 704   mController = Text::Controller::New( *this );
 705
 706   mDecorator = Text::Decorator::New( *this, *mController );
 707
 708   mController->GetLayoutEngine().SetLayout( LayoutEngine::SINGLE_LINE_BOX );
 709
 710   mController->EnableTextInput( mDecorator );
 711
 712   // Forward input events to controller
 713   EnableGestureDetection(Gesture::Tap);
 714   GetTapGestureDetector().SetMaximumTapsRequired( 2 );
 715   EnableGestureDetection(Gesture::Pan);
 716
 717   // Set BoundingBox to stage size if not already set.
 718   if ( mDecorator->GetBoundingBox().IsEmpty() )
 719   {
 720     Vector2 stageSize = Dali::Stage::GetCurrent().GetSize();
 721     mDecorator->SetBoundingBox( Rect<int>( 0.0f, 0.0f, stageSize.width, stageSize.height ) );
 722   }
 723
 724   // Fill-parent area by default
 725   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
 726   self.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
 727 }
 728
 729 void TextField::OnStyleChange( Toolkit::StyleManager styleManager, StyleChange change )
 730 {
 731   GetImpl( styleManager ).ApplyThemeStyle( Toolkit::Control( GetOwner() ) );
 732 }
 733
 734 Vector3 TextField::GetNaturalSize()
 735 {
 736   return mController->GetNaturalSize();
 737 }
 738
 739 float TextField::GetHeightForWidth( float width )
 740 {
 741   return mController->GetHeightForWidth( width );
 742 }
 743
 744 void TextField::OnRelayout( const Vector2& size, RelayoutContainer& container )
 745 {
 746   if( mController->Relayout( size ) ||
 747       !mRenderer )
 748   {
 749     if( mDecorator )
 750     {
 751       mDecorator->Relayout( size );
 752     }
 753
 754     if( !mRenderer )
 755     {
 756       mRenderer = Backend::Get().NewRenderer( mRenderingBackend );
 757     }
 758
 759     RenderableActor renderableActor;
 760     if( mRenderer )
 761     {
 762       renderableActor = mRenderer->Render( mController->GetView() );
 763     }
 764
 765     EnableClipping( (Dali::Toolkit::TextField::EXCEED_POLICY_CLIP == mExceedPolicy), size );
 766
 767     if( renderableActor != mRenderableActor )
 768     {
 769       UnparentAndReset( mRenderableActor );
 770       mRenderableActor = renderableActor;
 771     }
 772
 773     if( mRenderableActor )
 774     {
 775       const Vector2 offset = mController->GetScrollPosition() + mController->GetAlignmentOffset();
 776
 777       mRenderableActor.SetPosition( offset.x, offset.y );
 778
 779       // Make sure the actor is parented correctly with/without clipping
 780       if( mClipper )
 781       {
 782         mClipper->GetRootActor().Add( mRenderableActor );
 783       }
 784       else
 785       {
 786         Self().Add( mRenderableActor );
 787       }
 788     }
 789   }
 790 }
 791
 792 void TextField::OnKeyInputFocusGained()
 793 {
 794   VirtualKeyboard::StatusChangedSignal().Connect( this, &TextField::KeyboardStatusChanged );
 795
 796   ImfManager imfManager = ImfManager::Get();
 797
 798   if ( imfManager )
 799   {
 800     imfManager.EventReceivedSignal().Connect( this, &TextField::OnImfEvent );
 801
 802     // Notify that the text editing start.
 803     imfManager.Activate();
 804
 805     // When window gain lost focus, the imf manager is deactivated. Thus when window gain focus again, the imf manager must be activated.
 806     imfManager.SetRestoreAfterFocusLost( true );
 807   }
 808
 809   mController->KeyboardFocusGainEvent();
 810
 811   EmitKeyInputFocusSignal( true ); // Calls back into the Control hence done last.
 812 }
 813
 814 void TextField::OnKeyInputFocusLost()
 815 {
 816   VirtualKeyboard::StatusChangedSignal().Disconnect( this, &TextField::KeyboardStatusChanged );
 817
 818   ImfManager imfManager = ImfManager::Get();
 819   if ( imfManager )
 820   {
 821     // The text editing is finished. Therefore the imf manager don't have restore activation.
 822     imfManager.SetRestoreAfterFocusLost( false );
 823
 824     // Notify that the text editing finish.
 825     imfManager.Deactivate();
 826
 827     imfManager.EventReceivedSignal().Disconnect( this, &TextField::OnImfEvent );
 828   }
 829
 830   mController->KeyboardFocusLostEvent();
 831
 832   EmitKeyInputFocusSignal( false ); // Calls back into the Control hence done last.
 833 }
 834
 835 void TextField::OnTap( const TapGesture& gesture )
 836 {
 837   // Show the keyboard if it was hidden.
 838   if (!VirtualKeyboard::IsVisible())
 839   {
 840     VirtualKeyboard::Show();
 841   }
 842
 843   SetKeyInputFocus();
 844
 845   mController->TapEvent( gesture.numberOfTaps, gesture.localPoint.x, gesture.localPoint.y );
 846 }
 847
 848 void TextField::OnPan( const PanGesture& gesture )
 849 {
 850   mController->PanEvent( gesture.state, gesture.displacement );
 851 }
 852
 853 bool TextField::OnKeyEvent( const KeyEvent& event )
 854 {
 855   if( Dali::DALI_KEY_ESCAPE == event.keyCode )
 856   {
 857     ClearKeyInputFocus();
 858   }
 859
 860   return mController->KeyEvent( event );
 861 }
 862
 863 ImfManager::ImfCallbackData TextField::OnImfEvent( Dali::ImfManager& imfManager, const ImfManager::ImfEventData& imfEvent )
 864 {
 865   switch ( imfEvent.eventName )
 866   {
 867     case ImfManager::COMMIT:
 868     {
 869       KeyEvent event( "", imfEvent.predictiveString, 0, 0, 0, KeyEvent::Down );
 870       mController->KeyEvent( event );
 871       break;
 872     }
 873     case ImfManager::PREEDIT: // fall through
 874     case ImfManager::DELETESURROUNDING:
 875     case ImfManager::GETSURROUNDING:
 876     case ImfManager::VOID:
 877     {
 878       // do nothing
 879     }
 880   } // end switch
 881
 882   return ImfManager::ImfCallbackData();
 883 }
 884
 885 void TextField::RequestTextRelayout()
 886 {
 887   RelayoutRequest();
 888 }
 889
 890 void TextField::MaxLengthReached()
 891 {
 892   Dali::Toolkit::TextField handle( GetOwner() );
 893   mMaxLengthReachedSignal.Emit( handle );
 894 }
 895
 896 void TextField::EnableClipping( bool clipping, const Vector2& size )
 897 {
 898   if( clipping )
 899   {
 900     // Not worth to created clip actor if width or height is equal to zero.
 901     if( size.width > Math::MACHINE_EPSILON_1000 && size.height > Math::MACHINE_EPSILON_1000 )
 902     {
 903       if( !mClipper )
 904       {
 905         Actor self = Self();
 906
 907         mClipper = Clipper::New( size );
 908         self.Add( mClipper->GetRootActor() );
 909         self.Add( mClipper->GetImageActor() );
 910       }
 911       else if ( mClipper )
 912       {
 913         mClipper->Refresh( size );
 914       }
 915     }
 916   }
 917   else
 918   {
 919     // Note - this will automatically remove the root & image actors
 920     mClipper.Reset();
 921   }
 922 }
 923
 924 void TextField::KeyboardStatusChanged(bool keyboardShown)
 925 {
 926   // Just hide the grab handle when keyboard is hidden.
 927   if (!keyboardShown )
 928   {
 929     mController->KeyboardFocusLostEvent();
 930   }
 931 }
 932
 933 TextField::TextField()
 934 : Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
 935   mRenderingBackend( DEFAULT_RENDERING_BACKEND ),
 936   mExceedPolicy( Dali::Toolkit::TextField::EXCEED_POLICY_CLIP )
 937 {
 938 }
 939
 940 TextField::~TextField()
 941 {
 942   mClipper.Reset();
 943 }
 944
 945 } // namespace Internal
 946
 947 } // namespace Toolkit
 948
 949 } // namespace Dali