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