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