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