base/dali-toolkit/internal/controls/buttons/push-button-default-painter-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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
  20 #include "push-button-default-painter-impl.h"
  21
  22 // INTERNAL INCLUDES
  23
  24 #include <dali/public-api/actors/image-actor.h>
  25 #include <dali-toolkit/public-api/controls/text-view/text-view.h>
  26 #include <dali-toolkit/public-api/controls/buttons/push-button.h>
  27 #include <dali/public-api/object/ref-object.h>
  28
  29 #include "push-button-impl.h"
  30
  31 // EXTERNAL INCLUDES
  32
  33 namespace Dali
  34 {
  35
  36 namespace Toolkit
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 namespace
  43 {
  44 const float LABEL_DEPTH( 0.75f );
  45 const float FOREGROUND_DEPTH( 0.5f );
  46 const float BACKGROUND_DEPTH( 0.25f );
  47
  48 const float ANIMATION_TIME( 0.2f );
  49
  50 inline Toolkit::Internal::PushButton& GetPushButtonImpl( Toolkit::Button& button )
  51 {
  52   DALI_ASSERT_ALWAYS( button );
  53
  54   Dali::RefObject& handle = button.GetImplementation();
  55
  56   return static_cast<Toolkit::Internal::PushButton&>( handle );
  57 }
  58
  59 inline const Toolkit::Internal::PushButton& GetPushButtonImpl( const Toolkit::Button& button )
  60 {
  61   DALI_ASSERT_ALWAYS( button );
  62
  63   const Dali::RefObject& handle = button.GetImplementation();
  64
  65   return static_cast<const Toolkit::Internal::PushButton&>( handle );
  66 }
  67
  68 }
  69
  70 PushButtonDefaultPainter::PushButtonDefaultPainter()
  71 : PushButtonPainter(),
  72   mAutoRepeating( false ),
  73   mDimmed( false ),
  74   mPaintState( ReleasedState ),
  75   mButton( NULL ),
  76   mAnimationTime( ANIMATION_TIME ),
  77   mSize()
  78 {
  79 }
  80
  81 PushButtonDefaultPainter::~PushButtonDefaultPainter()
  82 {
  83   if( mFadeInAnimation )
  84   {
  85     mFadeInAnimation.Clear();
  86   }
  87   if( mFadeOutAnimation )
  88   {
  89     mFadeOutAnimation.Clear();
  90   }
  91 }
  92
  93 void PushButtonDefaultPainter::SetButtonImage( Toolkit::PushButton& pushButton, Actor image )
  94 {
  95   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
  96   Actor& buttonImage = pushButtonImpl.GetButtonImage();
  97   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
  98
  99   switch( mPaintState )
 100   {
 101     case ReleasedState:
 102     {
 103       if( buttonImage && buttonImage.GetParent() )
 104       {
 105         StopFadeOutAnimation( pushButton );
 106         FadeOutImage( pushButton, Foreground, buttonImage );
 107
 108         buttonImage = image;
 109
 110         FadeInImage( pushButton, buttonImage );
 111
 112         StartFadeOutAnimation( pushButton );
 113         StartFadeInAnimation();
 114       }
 115       else
 116       {
 117         buttonImage = image;
 118         pushButton.Add( buttonImage );
 119       }
 120       break;
 121     }
 122     case ReleasedPressedTransition: // FALLTHROUGH
 123     case ReleasedDimmedTransition:
 124     {
 125       float opacity = 1.f;
 126       if( fadeOutButtonImage )
 127       {
 128         opacity = fadeOutButtonImage.GetCurrentOpacity();
 129       }
 130       StopFadeOutAnimation( pushButton );
 131
 132       // Replaces the button image.
 133       buttonImage = image;
 134
 135       pushButton.Add( buttonImage );
 136       FadeOutImage( pushButton, Foreground, buttonImage, opacity );
 137
 138       StartFadeOutAnimation( pushButton );
 139       break;
 140     }
 141     case PressedReleasedTransition: // FALLTHROUGH
 142     case DimmedReleasedTransition:
 143     {
 144       StopFadeInAnimation();
 145       pushButton.Remove( buttonImage );
 146
 147       buttonImage = image;
 148
 149       FadeInImage( pushButton, buttonImage );
 150       StartFadeInAnimation();
 151       break;
 152     }
 153     default:
 154       buttonImage = image;
 155       break;
 156   }
 157
 158   buttonImage.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 159   buttonImage.SetParentOrigin( ParentOrigin::TOP_LEFT );
 160   ApplyConstraint( buttonImage, FOREGROUND_DEPTH );
 161 }
 162
 163 void PushButtonDefaultPainter::SetBackgroundImage( Toolkit::PushButton& pushButton, Actor image )
 164 {
 165   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
 166   Actor& backgroundImage = pushButtonImpl.GetBackgroundImage();
 167   Actor& fadeOutBackgroundImage = pushButtonImpl.GetFadeOutBackgroundImage();
 168
 169   switch( mPaintState )
 170   {
 171     case ReleasedState:             // FALLTHROUGH
 172     case PressedState:
 173     case ReleasedPressedTransition:
 174     case PressedReleasedTransition:
 175     {
 176       if( backgroundImage && backgroundImage.GetParent() )
 177       {
 178         StopFadeOutAnimation( pushButton );
 179         FadeOutImage( pushButton, Background, backgroundImage  );
 180
 181         backgroundImage = image;
 182
 183         FadeInImage( pushButton, backgroundImage );
 184
 185         StartFadeOutAnimation( pushButton );
 186         StartFadeInAnimation();
 187       }
 188       else
 189       {
 190         backgroundImage = image;
 191         pushButton.Add( backgroundImage );
 192       }
 193       break;
 194     }
 195     case ReleasedDimmedTransition: // FALLTHROUGH
 196     case PressedDimmedTransition:
 197     {
 198       float opacity = 1.f;
 199       if( fadeOutBackgroundImage )
 200       {
 201         opacity = fadeOutBackgroundImage.GetCurrentOpacity();
 202       }
 203       StopFadeOutAnimation( pushButton );
 204
 205       // Replaces the button image.
 206       backgroundImage = image;
 207
 208       pushButton.Add( backgroundImage );
 209       FadeOutImage( pushButton, Background, backgroundImage, opacity );
 210
 211       StartFadeOutAnimation( pushButton );
 212       break;
 213     }
 214     case DimmedReleasedTransition: // FALLTHROUGH
 215     case DimmedPressedTransition:
 216     {
 217       StopFadeInAnimation();
 218       pushButton.Remove( backgroundImage );
 219
 220       backgroundImage = image;
 221
 222       FadeInImage( pushButton, backgroundImage );
 223       StartFadeInAnimation();
 224       break;
 225     }
 226     default:
 227       backgroundImage = image;
 228       break;
 229     }
 230
 231   backgroundImage.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 232   backgroundImage.SetParentOrigin( ParentOrigin::TOP_LEFT );
 233   ApplyConstraint( backgroundImage, BACKGROUND_DEPTH );
 234 }
 235
 236 void PushButtonDefaultPainter::SetPressedImage( Toolkit::PushButton& pushButton, Actor image )
 237 {
 238   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
 239   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 240   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 241
 242   switch( mPaintState )
 243   {
 244     case PressedState:
 245     {
 246       if( pressedImage && pressedImage.GetParent() )
 247       {
 248         StopFadeOutAnimation( pushButton );
 249         FadeOutImage( pushButton, Foreground, pressedImage  );
 250
 251         pressedImage = image;
 252
 253         FadeInImage( pushButton, pressedImage );
 254
 255         StartFadeOutAnimation( pushButton );
 256         StartFadeInAnimation();
 257       }
 258       else
 259       {
 260         pressedImage = image;
 261         pushButton.Add( pressedImage );
 262       }
 263       break;
 264     }
 265     case PressedReleasedTransition: // FALLTHROUGH
 266     case PressedDimmedTransition:
 267     {
 268       float opacity = 1.f;
 269       if( fadeOutButtonImage )
 270       {
 271         opacity = fadeOutButtonImage.GetCurrentOpacity();
 272       }
 273       StopFadeOutAnimation( pushButton );
 274
 275       // Replaces the button image.
 276       pressedImage = image;
 277
 278       pushButton.Add( pressedImage );
 279       FadeOutImage( pushButton, Foreground, pressedImage, opacity );
 280
 281       StartFadeOutAnimation( pushButton );
 282       break;
 283     }
 284     case ReleasedPressedTransition: // FALLTHROUGH
 285     case DimmedPressedTransition:
 286     {
 287       StopFadeInAnimation();
 288       pushButton.Remove( pressedImage );
 289
 290       pressedImage = image;
 291
 292       FadeInImage( pushButton, pressedImage );
 293       StartFadeInAnimation();
 294       break;
 295     }
 296     default:
 297       pressedImage = image;
 298       break;
 299   }
 300
 301   pressedImage.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 302   pressedImage.SetParentOrigin( ParentOrigin::TOP_LEFT );
 303   ApplyConstraint( pressedImage, FOREGROUND_DEPTH );
 304 }
 305
 306 void PushButtonDefaultPainter::SetDimmedImage( Toolkit::PushButton& pushButton, Actor image )
 307 {
 308   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
 309   Actor& dimmedImage = pushButtonImpl.GetDimmedImage();
 310   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 311
 312   switch( mPaintState )
 313   {
 314     case DimmedReleasedState: // FALLTHROUGH
 315     case DimmedPressedState:
 316     {
 317       if( dimmedImage && dimmedImage.GetParent() )
 318       {
 319         StopFadeOutAnimation( pushButton );
 320         FadeOutImage( pushButton, Foreground, dimmedImage  );
 321
 322         dimmedImage = image;
 323
 324         FadeInImage( pushButton, dimmedImage );
 325
 326         StartFadeOutAnimation( pushButton );
 327         StartFadeInAnimation();
 328       }
 329       else
 330       {
 331         dimmedImage = image;
 332         pushButton.Add( dimmedImage );
 333       }
 334       break;
 335     }
 336     case ReleasedDimmedTransition: // FALLTHROUGH
 337     case PressedDimmedTransition:
 338     {
 339       StopFadeInAnimation();
 340       pushButton.Remove( dimmedImage );
 341
 342       dimmedImage = image;
 343
 344       FadeInImage( pushButton, dimmedImage );
 345       StartFadeInAnimation();
 346       break;
 347     }
 348     case DimmedReleasedTransition: // FALLTHROUGH
 349     case DimmedPressedTransition:
 350     {
 351       float opacity = 1.f;
 352       if( fadeOutButtonImage )
 353       {
 354         opacity = fadeOutButtonImage.GetCurrentOpacity();
 355       }
 356       StopFadeOutAnimation( pushButton );
 357
 358       // Replaces the button image.
 359       dimmedImage = image;
 360
 361       pushButton.Add( dimmedImage );
 362       FadeOutImage( pushButton, Foreground, dimmedImage, opacity );
 363
 364       StartFadeOutAnimation( pushButton );
 365       break;
 366     }
 367     default:
 368       dimmedImage = image;
 369       break;
 370   }
 371
 372   dimmedImage.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 373   dimmedImage.SetParentOrigin( ParentOrigin::TOP_LEFT );
 374   ApplyConstraint( dimmedImage, FOREGROUND_DEPTH );
 375 }
 376
 377 void PushButtonDefaultPainter::SetDimmedBackgroundImage( Toolkit::PushButton& pushButton, Actor image )
 378 {
 379   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
 380   Actor& dimmedBackgroundImage = pushButtonImpl.GetDimmedBackgroundImage();
 381   Actor& fadeOutBackgroundImage = pushButtonImpl.GetFadeOutBackgroundImage();
 382
 383   switch( mPaintState )
 384   {
 385     case DimmedReleasedState: // FALLTHROUGH
 386     case DimmedPressedState:
 387     {
 388       if( dimmedBackgroundImage && dimmedBackgroundImage.GetParent() )
 389       {
 390         StopFadeOutAnimation( pushButton );
 391         FadeOutImage( pushButton, Background, dimmedBackgroundImage  );
 392
 393         dimmedBackgroundImage = image;
 394
 395         FadeInImage( pushButton, dimmedBackgroundImage );
 396
 397         StartFadeOutAnimation( pushButton );
 398         StartFadeInAnimation();
 399       }
 400       else
 401       {
 402         dimmedBackgroundImage = image;
 403         pushButton.Add( dimmedBackgroundImage );
 404       }
 405       break;
 406     }
 407     case ReleasedDimmedTransition: // FALLTHROUGH
 408     case PressedDimmedTransition:
 409     {
 410       StopFadeInAnimation();
 411       pushButton.Remove( dimmedBackgroundImage );
 412
 413       dimmedBackgroundImage = image;
 414
 415       FadeInImage( pushButton, dimmedBackgroundImage );
 416       StartFadeInAnimation();
 417       break;
 418     }
 419     case DimmedReleasedTransition: // FALLTHROUGH
 420     case DimmedPressedTransition:
 421     {
 422       float opacity = 1.f;
 423       if( fadeOutBackgroundImage )
 424       {
 425         opacity = fadeOutBackgroundImage.GetCurrentOpacity();
 426       }
 427       StopFadeOutAnimation( pushButton );
 428
 429       // Replaces the button image.
 430       dimmedBackgroundImage = image;
 431
 432       pushButton.Add( dimmedBackgroundImage );
 433       FadeOutImage( pushButton, Background, dimmedBackgroundImage, opacity );
 434
 435       StartFadeOutAnimation( pushButton );
 436       break;
 437     }
 438     default:
 439       dimmedBackgroundImage = image;
 440       break;
 441   }
 442
 443   dimmedBackgroundImage.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 444   dimmedBackgroundImage.SetParentOrigin( ParentOrigin::TOP_LEFT );
 445   ApplyConstraint( dimmedBackgroundImage, BACKGROUND_DEPTH );
 446 }
 447
 448 void PushButtonDefaultPainter::SetLabelText( Toolkit::PushButton& pushButton, Actor text )
 449 {
 450   Toolkit::Internal::PushButton& pushButtonImpl = GetImplementation( pushButton );
 451   Actor& label = pushButtonImpl.GetLabel();
 452
 453   if( label && label.GetParent() )
 454   {
 455     label.GetParent().Remove( label );
 456   }
 457
 458   label = text;
 459   label.SetAnchorPoint( AnchorPoint::CENTER );
 460   label.SetParentOrigin( ParentOrigin::CENTER );
 461
 462   label.SetPosition( 0.f, 0.f, LABEL_DEPTH );
 463   label.SetSize( mSize );
 464
 465   pushButton.Add( label  );
 466 }
 467
 468 void PushButtonDefaultPainter::Initialize( Toolkit::Button& button )
 469 {
 470   Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 471   Actor& buttonImage = pushButtonImpl.GetButtonImage();
 472   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 473   Actor& backgroundImage = pushButtonImpl.GetBackgroundImage();
 474   Actor& dimmedImage = pushButtonImpl.GetDimmedImage();
 475   Actor& dimmedBackgroundImage = pushButtonImpl.GetDimmedBackgroundImage();
 476   Actor& label = pushButtonImpl.GetLabel();
 477
 478   Toolkit::PushButton& pushButton = static_cast<Toolkit::PushButton&>( button );
 479
 480   if( buttonImage )
 481   {
 482     SetButtonImage( pushButton, buttonImage );
 483   }
 484
 485   if( backgroundImage )
 486   {
 487     SetBackgroundImage( pushButton, backgroundImage );
 488   }
 489
 490   if( pressedImage )
 491   {
 492     SetPressedImage( pushButton, pressedImage );
 493   }
 494
 495   if( dimmedImage )
 496   {
 497     SetDimmedImage( pushButton, dimmedImage );
 498   }
 499
 500   if( dimmedBackgroundImage )
 501   {
 502     SetDimmedBackgroundImage( pushButton, dimmedBackgroundImage );
 503   }
 504
 505   if( label )
 506   {
 507     SetLabelText( pushButton, label );
 508   }
 509
 510   SetDimmed( pushButton, mDimmed );
 511 }
 512
 513 void PushButtonDefaultPainter::SetSize( Toolkit::Button& button, const Vector3& size )
 514 {
 515   if( size != mSize )
 516   {
 517     mSize = size;
 518
 519     Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 520     Actor& buttonImage = pushButtonImpl.GetButtonImage();
 521     Actor& pressedImage = pushButtonImpl.GetPressedImage();
 522     Actor& backgroundImage = pushButtonImpl.GetBackgroundImage();
 523     Actor& dimmedImage = pushButtonImpl.GetDimmedImage();
 524     Actor& dimmedBackgroundImage = pushButtonImpl.GetDimmedBackgroundImage();
 525     Actor& label = pushButtonImpl.GetLabel();
 526
 527     ApplyConstraint( buttonImage, FOREGROUND_DEPTH );
 528     ApplyConstraint( backgroundImage, BACKGROUND_DEPTH );
 529     ApplyConstraint( pressedImage, FOREGROUND_DEPTH );
 530     ApplyConstraint( dimmedImage, FOREGROUND_DEPTH );
 531     ApplyConstraint( dimmedBackgroundImage, BACKGROUND_DEPTH );
 532
 533     if( label )
 534     {
 535       label.SetPosition( 0.f, 0.f, LABEL_DEPTH );
 536       label.SetSize( mSize );
 537     }
 538   }
 539 }
 540
 541 void PushButtonDefaultPainter::SetDimmed( Toolkit::Button& button, bool dimmed )
 542 {
 543   Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 544   Actor& buttonImage = pushButtonImpl.GetButtonImage();
 545   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 546   Actor& backgroundImage = pushButtonImpl.GetBackgroundImage();
 547   Actor& dimmedImage = pushButtonImpl.GetDimmedImage();
 548   Actor& dimmedBackgroundImage = pushButtonImpl.GetDimmedBackgroundImage();
 549   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 550
 551   Toolkit::PushButton& pushButton = static_cast<Toolkit::PushButton&>( button );
 552
 553   mDimmed = dimmed;
 554
 555   switch( mPaintState )
 556   {
 557   case ReleasedState:
 558   {
 559     if( dimmed )
 560     {
 561       StopFadeOutAnimation( pushButton );
 562       FadeOutImage( pushButton, Background, backgroundImage );
 563       FadeOutImage( pushButton, Foreground, buttonImage );
 564       FadeInImage( pushButton, dimmedBackgroundImage );
 565       FadeInImage( pushButton, dimmedImage );
 566       StartFadeOutAnimation( pushButton );
 567       StartFadeInAnimation();
 568
 569       if( buttonImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 570       {
 571         mPaintState = ReleasedDimmedTransition;
 572       }
 573       else
 574       {
 575         mPaintState = DimmedReleasedState;
 576       }
 577     }
 578     break;
 579   }
 580   case PressedState:
 581   {
 582     if( dimmed )
 583     {
 584       StopFadeOutAnimation( pushButton );
 585       FadeOutImage( pushButton, Background, backgroundImage );
 586       FadeOutImage( pushButton, Foreground, pressedImage );
 587       FadeInImage( pushButton, dimmedBackgroundImage );
 588       FadeInImage( pushButton, dimmedImage );
 589       StartFadeOutAnimation( pushButton );
 590       StartFadeInAnimation();
 591
 592       if( pressedImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 593       {
 594         mPaintState = PressedDimmedTransition;
 595       }
 596       else
 597       {
 598         mPaintState = DimmedPressedState;
 599       }
 600     }
 601     break;
 602   }
 603   case DimmedReleasedState:
 604   {
 605     if( !dimmed )
 606     {
 607       StopFadeOutAnimation( pushButton );
 608       FadeOutImage( pushButton, Background, dimmedBackgroundImage );
 609       FadeOutImage( pushButton, Foreground, dimmedImage );
 610       FadeInImage( pushButton, backgroundImage );
 611       FadeInImage( pushButton, buttonImage );
 612       StartFadeOutAnimation( pushButton );
 613       StartFadeInAnimation();
 614
 615       if( buttonImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 616       {
 617         mPaintState = DimmedReleasedTransition;
 618       }
 619       else
 620       {
 621         mPaintState = ReleasedState;
 622       }
 623     }
 624     break;
 625   }
 626   case DimmedPressedState:
 627   {
 628     if( !dimmed )
 629     {
 630       StopFadeOutAnimation( pushButton );
 631       FadeOutImage( pushButton, Background, dimmedBackgroundImage );
 632       FadeOutImage( pushButton, Foreground, dimmedImage );
 633       FadeInImage( pushButton, backgroundImage );
 634       FadeInImage( pushButton, pressedImage );
 635       StartFadeOutAnimation( pushButton );
 636       StartFadeInAnimation();
 637
 638       if( pressedImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 639       {
 640         mPaintState = DimmedPressedTransition;
 641       }
 642       else
 643       {
 644         mPaintState = PressedState;
 645       }
 646     }
 647     break;
 648   }
 649   case ReleasedPressedTransition:
 650   {
 651     if( dimmed )
 652     {
 653       float opacity = 1.f;
 654       if( fadeOutButtonImage )
 655       {
 656         opacity = fadeOutButtonImage.GetCurrentOpacity();
 657       }
 658       StopFadeOutAnimation( pushButton );
 659       StopFadeInAnimation();
 660
 661       FadeOutImage( pushButton, Foreground, pressedImage, 1.f - opacity );
 662       FadeOutImage( pushButton, Background, backgroundImage );
 663
 664       FadeInImage( pushButton, dimmedImage );
 665       FadeInImage( pushButton, dimmedBackgroundImage );
 666
 667       StartFadeOutAnimation( pushButton );
 668       StartFadeInAnimation();
 669
 670       if( pressedImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 671       {
 672         mPaintState = PressedDimmedTransition;
 673       }
 674       else
 675       {
 676         mPaintState = DimmedPressedState;
 677       }
 678     }
 679     break;
 680   }
 681   case PressedReleasedTransition:
 682   {
 683     if( dimmed )
 684     {
 685       float opacity = 1.f;
 686       if( fadeOutButtonImage )
 687       {
 688         opacity = fadeOutButtonImage.GetCurrentOpacity();
 689       }
 690       StopFadeOutAnimation( pushButton );
 691       StopFadeInAnimation();
 692
 693       FadeOutImage( pushButton, Foreground, buttonImage, 1.f - opacity );
 694       FadeOutImage( pushButton, Background, backgroundImage );
 695
 696       FadeInImage( pushButton, dimmedImage );
 697       FadeInImage( pushButton, dimmedBackgroundImage );
 698
 699       StartFadeOutAnimation( pushButton );
 700       StartFadeInAnimation();
 701
 702       if( buttonImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 703       {
 704         mPaintState = ReleasedDimmedTransition;
 705       }
 706       else
 707       {
 708         mPaintState = DimmedReleasedState;
 709       }
 710     }
 711     break;
 712   }
 713   case ReleasedDimmedTransition:
 714   {
 715     if( !dimmed )
 716     {
 717       float opacity = 1.f;
 718       if( fadeOutButtonImage )
 719       {
 720         opacity = fadeOutButtonImage.GetCurrentOpacity();
 721       }
 722       StopFadeOutAnimation( pushButton, false );
 723       StopFadeInAnimation();
 724
 725       FadeOutImage( pushButton, Foreground, dimmedImage, 1.f - opacity );
 726       FadeOutImage( pushButton, Background, dimmedBackgroundImage, 1.f - opacity );
 727       FadeInImage( pushButton, buttonImage, opacity );
 728       FadeInImage( pushButton, backgroundImage, opacity );
 729
 730       StartFadeOutAnimation( pushButton );
 731       StartFadeInAnimation();
 732
 733       if( buttonImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 734       {
 735         mPaintState = DimmedReleasedTransition;
 736       }
 737       else
 738       {
 739         mPaintState = ReleasedState;
 740       }
 741     }
 742     break;
 743   }
 744   case DimmedReleasedTransition:
 745   {
 746     if( dimmed )
 747     {
 748       float opacity = 1.f;
 749       if( fadeOutButtonImage )
 750       {
 751         opacity = fadeOutButtonImage.GetCurrentOpacity();
 752       }
 753       StopFadeOutAnimation( pushButton, false );
 754       StopFadeInAnimation();
 755
 756       FadeOutImage( pushButton, Foreground, buttonImage, 1.f - opacity );
 757       FadeOutImage( pushButton, Background, backgroundImage, 1.f - opacity );
 758       FadeInImage( pushButton, dimmedImage, opacity );
 759       FadeInImage( pushButton, dimmedBackgroundImage, opacity );
 760
 761       StartFadeOutAnimation( pushButton );
 762       StartFadeInAnimation();
 763
 764       if( buttonImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 765       {
 766         mPaintState = ReleasedDimmedTransition;
 767       }
 768       else
 769       {
 770         mPaintState = DimmedReleasedState;
 771       }
 772     }
 773     break;
 774   }
 775   case PressedDimmedTransition:
 776   {
 777     if( !dimmed )
 778     {
 779       float opacity = 1.f;
 780       if( fadeOutButtonImage )
 781       {
 782         opacity = fadeOutButtonImage.GetCurrentOpacity();
 783       }
 784       StopFadeOutAnimation( pushButton, false );
 785       StopFadeInAnimation();
 786
 787       FadeOutImage( pushButton, Foreground, dimmedImage, 1.f - opacity );
 788       FadeOutImage( pushButton, Background, dimmedBackgroundImage, 1.f - opacity );
 789       FadeInImage( pushButton, pressedImage, opacity );
 790       FadeInImage( pushButton, backgroundImage, opacity );
 791
 792       StartFadeOutAnimation( pushButton );
 793       StartFadeInAnimation();
 794
 795       if( pressedImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 796       {
 797         mPaintState = DimmedPressedTransition;
 798       }
 799       else
 800       {
 801         mPaintState = PressedState;
 802       }
 803     }
 804     break;
 805   }
 806   case DimmedPressedTransition:
 807   {
 808     if( dimmed )
 809     {
 810       float opacity = 1.f;
 811       if( fadeOutButtonImage )
 812       {
 813         opacity = fadeOutButtonImage.GetCurrentOpacity();
 814       }
 815       StopFadeOutAnimation( pushButton, false );
 816       StopFadeInAnimation();
 817
 818       FadeOutImage( pushButton, Foreground, pressedImage, 1.f - opacity );
 819       FadeOutImage( pushButton, Background, backgroundImage, 1.f - opacity );
 820       FadeInImage( pushButton, dimmedImage, opacity );
 821       FadeInImage( pushButton, dimmedBackgroundImage, opacity );
 822
 823       StartFadeOutAnimation( pushButton );
 824       StartFadeInAnimation();
 825
 826       if( pressedImage || dimmedImage || backgroundImage || dimmedBackgroundImage )
 827       {
 828         mPaintState = PressedDimmedTransition;
 829       }
 830       else
 831       {
 832         mPaintState = DimmedPressedState;
 833       }
 834     }
 835     break;
 836   }
 837   default:
 838     break;
 839   }
 840 }
 841
 842 void PushButtonDefaultPainter::SetAnimationTime( float animationTime )
 843 {
 844   mAnimationTime = animationTime;
 845 }
 846
 847 float PushButtonDefaultPainter::GetAnimationTime() const
 848 {
 849   return mAnimationTime;
 850 }
 851
 852 void PushButtonDefaultPainter::SetAutoRepeating( bool autorepeating )
 853 {
 854   mAutoRepeating = autorepeating;
 855 }
 856
 857 void PushButtonDefaultPainter::Pressed( Toolkit::PushButton& button )
 858 {
 859   Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 860   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 861   Actor& buttonImage = pushButtonImpl.GetButtonImage();
 862   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 863
 864   switch( mPaintState )
 865   {
 866     case ReleasedState:
 867     {
 868       StopFadeOutAnimation( button );
 869       FadeOutImage( button, Foreground, buttonImage );
 870       FadeInImage( button, pressedImage );
 871       StartFadeOutAnimation( button );
 872       StartFadeInAnimation();
 873
 874       if( buttonImage || pressedImage )
 875       {
 876         mPaintState = ReleasedPressedTransition;
 877       }
 878       else
 879       {
 880         mPaintState = PressedState;
 881       }
 882       break;
 883     }
 884     case ReleasedPressedTransition:
 885     {
 886       if( !mAutoRepeating )
 887       {
 888         mPaintState = PressedReleasedTransition;
 889       }
 890       break;
 891     }
 892     case PressedReleasedTransition:
 893     {
 894       float opacity = 1.f;
 895       if( fadeOutButtonImage )
 896       {
 897         opacity = fadeOutButtonImage.GetCurrentOpacity();
 898       }
 899       StopFadeOutAnimation( button, false );
 900       StopFadeInAnimation();
 901
 902       FadeOutImage( button, Foreground, buttonImage, 1.f - opacity );
 903       FadeInImage( button, pressedImage, opacity );
 904
 905       StartFadeOutAnimation( button );
 906       StartFadeInAnimation();
 907
 908       if( buttonImage || pressedImage )
 909       {
 910         mPaintState = ReleasedPressedTransition;
 911       }
 912       else
 913       {
 914         mPaintState = PressedState;
 915       }
 916       break;
 917     }
 918     default:
 919       break;
 920   }
 921 }
 922
 923 void PushButtonDefaultPainter::Released( Toolkit::PushButton& button )
 924 {
 925   Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 926   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 927   Actor& buttonImage = pushButtonImpl.GetButtonImage();
 928   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 929
 930   switch( mPaintState )
 931   {
 932     case PressedState:
 933     {
 934       StopFadeOutAnimation( button );
 935       FadeOutImage( button, Foreground, pressedImage );
 936       FadeInImage( button, buttonImage );
 937       StartFadeOutAnimation( button );
 938       StartFadeInAnimation();
 939
 940       if( buttonImage || pressedImage )
 941       {
 942         mPaintState = PressedReleasedTransition;
 943       }
 944       else
 945       {
 946         mPaintState = ReleasedState;
 947       }
 948       break;
 949     }
 950     case ReleasedPressedTransition:
 951     {
 952       float opacity = 1.f;
 953       if( fadeOutButtonImage )
 954       {
 955         opacity = fadeOutButtonImage.GetCurrentOpacity();
 956       }
 957       StopFadeOutAnimation( button, false );
 958       StopFadeInAnimation();
 959
 960       FadeOutImage( button, Foreground, pressedImage, 1.f - opacity );
 961       FadeInImage( button, buttonImage, opacity );
 962
 963       StartFadeOutAnimation( button );
 964       StartFadeInAnimation();
 965
 966       if( buttonImage || pressedImage )
 967       {
 968         mPaintState = PressedReleasedTransition;
 969       }
 970       else
 971       {
 972         mPaintState = ReleasedState;
 973       }
 974       break;
 975     }
 976     default:
 977     {
 978       break;
 979     }
 980   }
 981 }
 982
 983 void PushButtonDefaultPainter::Clicked( Toolkit::PushButton& button )
 984 {
 985   Released( button );
 986 }
 987
 988 void PushButtonDefaultPainter::Toggled( Toolkit::PushButton& button )
 989 {
 990   Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( button );
 991   Actor& pressedImage = pushButtonImpl.GetPressedImage();
 992   Actor& buttonImage = pushButtonImpl.GetButtonImage();
 993   Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
 994
 995   switch( mPaintState )
 996   {
 997     case ReleasedState:
 998     {
 999       StopFadeOutAnimation( button );
1000       FadeOutImage( button, Foreground, buttonImage );
1001       FadeInImage( button, pressedImage );
1002       StartFadeOutAnimation( button );
1003       StartFadeInAnimation();
1004
1005       if( buttonImage || pressedImage )
1006       {
1007         mPaintState = ReleasedPressedTransition;
1008       }
1009       else
1010       {
1011         mPaintState = PressedState;
1012       }
1013       break;
1014     }
1015     case PressedState:
1016     {
1017       StopFadeOutAnimation( button );
1018       FadeOutImage( button, Foreground, pressedImage );
1019       FadeInImage( button, buttonImage );
1020       StartFadeOutAnimation( button );
1021       StartFadeInAnimation();
1022
1023       if( buttonImage || pressedImage )
1024       {
1025         mPaintState = PressedReleasedTransition;
1026       }
1027       else
1028       {
1029         mPaintState = ReleasedState;
1030       }
1031       break;
1032     }
1033     case ReleasedPressedTransition:
1034     {
1035       float opacity = 1.f;
1036       if( fadeOutButtonImage )
1037       {
1038         opacity = fadeOutButtonImage.GetCurrentOpacity();
1039       }
1040       StopFadeOutAnimation( button, false );
1041       StopFadeInAnimation();
1042
1043       FadeOutImage( button, Foreground, pressedImage, 1.f - opacity );
1044       FadeInImage( button, buttonImage, opacity );
1045
1046       StartFadeOutAnimation( button );
1047       StartFadeInAnimation();
1048
1049       if( buttonImage || pressedImage )
1050       {
1051         mPaintState = PressedReleasedTransition;
1052       }
1053       else
1054       {
1055         mPaintState = ReleasedState;
1056       }
1057       break;
1058     }
1059     case PressedReleasedTransition:
1060     {
1061       float opacity = 0.f;
1062       if( fadeOutButtonImage )
1063       {
1064         opacity = 1.f - fadeOutButtonImage.GetCurrentOpacity();
1065       }
1066       StopFadeOutAnimation( button, false );
1067       StopFadeInAnimation();
1068
1069       FadeOutImage( button, Foreground, buttonImage, 1.f - opacity );
1070       FadeInImage( button, pressedImage, opacity );
1071
1072       StartFadeOutAnimation( button );
1073       StartFadeInAnimation();
1074
1075       if( buttonImage || pressedImage )
1076       {
1077         mPaintState = ReleasedPressedTransition;
1078       }
1079       else
1080       {
1081         mPaintState = PressedState;
1082       }
1083       break;
1084     }
1085     default:
1086     {
1087       break;
1088     }
1089   }
1090 }
1091
1092 void PushButtonDefaultPainter::ApplyConstraint( Actor& actor, float depth )
1093 {
1094   if( actor )
1095   {
1096     actor.SetPosition( 0.f, 0.f, depth );
1097     actor.RemoveConstraints();
1098     actor.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) );
1099   }
1100 }
1101
1102 void PushButtonDefaultPainter::AddToFadeInAnimation( const Actor& actor )
1103 {
1104   if( !mFadeInAnimation )
1105   {
1106     mFadeInAnimation = Dali::Animation::New( mAnimationTime );
1107   }
1108
1109   mFadeInAnimation.OpacityTo( actor, 1.f );
1110 }
1111
1112 void PushButtonDefaultPainter::StartFadeInAnimation()
1113 {
1114   if( mFadeInAnimation )
1115   {
1116     mFadeInAnimation.FinishedSignal().Connect( this, &PushButtonDefaultPainter::PressedReleasedFadeInAnimationFinished );
1117     mFadeInAnimation.Play();
1118   }
1119 }
1120
1121 void PushButtonDefaultPainter::StopFadeInAnimation()
1122 {
1123   if( mFadeInAnimation )
1124   {
1125     mFadeInAnimation.Clear();
1126     mFadeInAnimation.Reset();
1127   }
1128 }
1129
1130 void PushButtonDefaultPainter::AddToFadeOutAnimation( const Actor& actor )
1131 {
1132   if( !mFadeOutAnimation )
1133   {
1134     mFadeOutAnimation = Dali::Animation::New( mAnimationTime );
1135   }
1136
1137   mFadeOutAnimation.OpacityTo( actor, 0.f );
1138 }
1139
1140 void PushButtonDefaultPainter::StartFadeOutAnimation( Toolkit::PushButton& pushButton )
1141 {
1142   if( mFadeOutAnimation )
1143   {
1144     Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( pushButton );
1145     mButton = &pushButtonImpl;
1146
1147     mFadeOutAnimation.FinishedSignal().Connect( this, &PushButtonDefaultPainter::PressedReleasedFadeOutAnimationFinished );
1148     mFadeOutAnimation.Play();
1149   }
1150 }
1151
1152 void PushButtonDefaultPainter::StopFadeOutAnimation( Toolkit::PushButton& pushButton, bool remove )
1153 {
1154   if( mFadeOutAnimation )
1155   {
1156     mFadeOutAnimation.Clear();
1157   }
1158
1159   mFadeOutAnimation.Reset();
1160
1161   if( remove )
1162   {
1163     Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( pushButton );
1164     Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
1165     Actor& fadeOutBackgroundImage = pushButtonImpl.GetFadeOutBackgroundImage();
1166
1167     if( fadeOutButtonImage && fadeOutButtonImage.GetParent() )
1168     {
1169       fadeOutButtonImage.GetParent().Remove( fadeOutButtonImage );
1170     }
1171
1172     if( fadeOutBackgroundImage && fadeOutBackgroundImage.GetParent() )
1173     {
1174       fadeOutBackgroundImage.GetParent().Remove( fadeOutBackgroundImage );
1175     }
1176
1177     fadeOutButtonImage.Reset();
1178     fadeOutBackgroundImage.Reset();
1179   }
1180 }
1181
1182 void PushButtonDefaultPainter::FadeInImage( Toolkit::PushButton& pushButton, Actor& image, float opacity )
1183 {
1184   if( image )
1185   {
1186     image.SetOpacity( opacity );
1187     if( !image.GetParent() )
1188     {
1189       pushButton.Add( image );
1190     }
1191
1192     AddToFadeInAnimation( image );
1193   }
1194 }
1195
1196 void PushButtonDefaultPainter::FadeOutImage( Toolkit::PushButton& pushButton, ImageLayer layer, Actor& image, float opacity )
1197 {
1198   if( image )
1199   {
1200     Toolkit::Internal::PushButton& pushButtonImpl = GetPushButtonImpl( pushButton );
1201     Actor& fadeOutButtonImage = pushButtonImpl.GetFadeOutButtonImage();
1202     Actor& fadeOutBackgroundImage = pushButtonImpl.GetFadeOutBackgroundImage();
1203
1204     Actor& actorLayer = ( ( Background == layer ) ? fadeOutBackgroundImage : fadeOutButtonImage );
1205
1206     actorLayer = image;
1207     actorLayer.SetOpacity( opacity );
1208
1209     AddToFadeOutAnimation( actorLayer );
1210   }
1211 }
1212
1213 void PushButtonDefaultPainter::PressedReleasedFadeOutAnimationFinished( Dali::Animation& source )
1214 {
1215   switch( mPaintState )
1216   {
1217     case ReleasedPressedTransition:
1218     {
1219       mPaintState = PressedState;
1220       break;
1221     }
1222     case PressedReleasedTransition:
1223     {
1224       mPaintState = ReleasedState;
1225       break;
1226     }
1227     case ReleasedDimmedTransition:
1228     {
1229       mPaintState = DimmedReleasedState;
1230       break;
1231     }
1232     case DimmedReleasedTransition:
1233     {
1234       mPaintState = ReleasedState;
1235       break;
1236     }
1237     case PressedDimmedTransition:
1238     {
1239       mPaintState = DimmedPressedState;
1240       break;
1241     }
1242     case DimmedPressedTransition:
1243     {
1244       mPaintState = PressedState;
1245       break;
1246     }
1247     default:
1248     {
1249       break;
1250     }
1251   }
1252
1253   Toolkit::PushButton handle( mButton->GetOwner() );
1254   StopFadeOutAnimation( handle );
1255   mButton = NULL;
1256 }
1257
1258 void PushButtonDefaultPainter::PressedReleasedFadeInAnimationFinished( Dali::Animation& source )
1259 {
1260   switch( mPaintState )
1261   {
1262     case ReleasedPressedTransition:
1263     {
1264       mPaintState = PressedState;
1265       break;
1266     }
1267     case PressedReleasedTransition:
1268     {
1269       mPaintState = ReleasedState;
1270       break;
1271     }
1272     case ReleasedDimmedTransition:
1273     {
1274       mPaintState = DimmedReleasedState;
1275       break;
1276     }
1277     case DimmedReleasedTransition:
1278     {
1279       mPaintState = ReleasedState;
1280       break;
1281     }
1282     case PressedDimmedTransition:
1283     {
1284       mPaintState = DimmedPressedState;
1285       break;
1286     }
1287     case DimmedPressedTransition:
1288     {
1289       mPaintState = PressedState;
1290       break;
1291     }
1292     default:
1293     {
1294       break;
1295     }
1296   }
1297
1298   StopFadeInAnimation();
1299 }
1300
1301 } // namespace Internal
1302
1303 } // namespace Toolkit
1304
1305 } // namespace Dali