dali-toolkit/internal/controls/popup/popup-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 <dali-toolkit/internal/controls/popup/popup-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/adaptor-framework/key.h>
  23 #include <dali/public-api/adaptor-framework/physical-keyboard.h>
  24 #include <dali/public-api/animation/constraints.h>
  25 #include <dali/public-api/common/stage.h>
  26 #include <dali/public-api/events/key-event.h>
  27 #include <dali/public-api/events/touch-event.h>
  28 #include <dali/public-api/images/resource-image.h>
  29 #include <dali/public-api/object/type-registry.h>
  30 #include <dali/public-api/object/type-registry-helper.h>
  31 #include <dali/public-api/size-negotiation/relayout-container.h>
  32 #include <dali/integration-api/debug.h>
  33
  34 // INTERNAL INCLUDES
  35 #include <dali-toolkit/public-api/controls/buttons/button.h>
  36 #include <dali-toolkit/public-api/controls/control-impl.h>
  37 #include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
  38 #include <dali-toolkit/public-api/focus-manager/focus-manager.h>
  39 #include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
  40
  41 using namespace Dali;
  42
  43 namespace Dali
  44 {
  45
  46 namespace Toolkit
  47 {
  48
  49 namespace Internal
  50 {
  51
  52 namespace
  53 {
  54
  55 BaseHandle Create()
  56 {
  57   return Toolkit::Popup::New();
  58 }
  59
  60 // Setup properties, signals and actions using the type-registry.
  61 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Popup, Toolkit::Control, Create )
  62
  63 DALI_SIGNAL_REGISTRATION( Popup, "touched-outside", SIGNAL_TOUCHED_OUTSIDE )
  64 DALI_SIGNAL_REGISTRATION( Popup, "hidden",          SIGNAL_HIDDEN          )
  65
  66 DALI_TYPE_REGISTRATION_END()
  67
  68 // Properties
  69 const char* const PROPERTY_TITLE = "title";
  70 const char* const PROPERTY_STATE = "state";
  71
  72 const float POPUP_ANIMATION_DURATION = 0.45f;                      ///< Duration of hide/show animations
  73
  74 const float POPUP_WIDTH = 720.0f;                             ///< Width of Popup
  75 const float POPUP_OUT_MARGIN_WIDTH = 16.f;                    ///< Space between the screen edge and the popup edge in the horizontal dimension.
  76 const float POPUP_OUT_MARGIN_HEIGHT = 36.f;                   ///< Space between the screen edge and the popup edge in the vertical dimension.
  77 const float POPUP_TITLE_WIDTH = 648.0f;                       ///<Width of Popup Title
  78 const float POPUP_BUTTON_BG_HEIGHT = 96.f;                    ///< Height of Button Background.
  79 const Vector3 DEFAULT_DIALOG_SIZE = Vector3(POPUP_TITLE_WIDTH/POPUP_WIDTH, 0.5f, 0.0f);
  80 const Vector3 DEFAULT_BOTTOM_SIZE = Vector3(1.0f, 0.2f, 0.0f);
  81
  82 } // unnamed namespace
  83
  84 ///////////////////////////////////////////////////////////////////////////////////////////////////
  85 // Popup
  86 ///////////////////////////////////////////////////////////////////////////////////////////////////
  87
  88 Dali::Toolkit::Popup Popup::New()
  89 {
  90   PopupStylePtr style = PopupStyleDefault::New();
  91
  92   // Create the implementation
  93   PopupPtr popup(new Popup(*style));
  94
  95   // Pass ownership to CustomActor via derived handle
  96   Dali::Toolkit::Popup handle(*popup);
  97
  98   // Second-phase init of the implementation
  99   // This can only be done after the CustomActor connection has been made...
 100   popup->Initialize();
 101
 102   return handle;
 103 }
 104
 105 Popup::Popup(PopupStyle& style)
 106 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
 107   mShowing(false),
 108   mState(Toolkit::Popup::POPUP_NONE), // Initially, the popup state should not be set, it's set in OnInitialize
 109   mAlterAddedChild(false),
 110   mPopupStyle(PopupStylePtr(&style)),
 111   mPropertyTitle(Property::INVALID_INDEX),
 112   mPropertyState(Property::INVALID_INDEX)
 113 {
 114   SetKeyboardNavigationSupport( true );
 115 }
 116
 117 void Popup::OnInitialize()
 118 {
 119   Dali::Stage stage = Dali::Stage::GetCurrent();
 120
 121   Actor self = Self();
 122   self.SetSensitive(false);
 123   // Reisize to fit the height of children
 124   self.SetResizePolicy( FIT_TO_CHILDREN, HEIGHT );
 125
 126   // Create Layer
 127   mLayer = Layer::New();
 128   mLayer.SetName( "POPUP_LAYER" );
 129   mLayer.SetParentOrigin(ParentOrigin::CENTER);
 130   mLayer.SetAnchorPoint(AnchorPoint::CENTER);
 131   mLayer.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 132   mLayer.SetDrawMode( DrawMode::OVERLAY );
 133
 134   // Any content after this point which is added to Self() will be reparented to
 135   // mContent.
 136   mAlterAddedChild = true;
 137   // Add Backing (Dim effect)
 138   CreateBacking();
 139   mAlterAddedChild = false;
 140
 141   // Add Dialog ( background image, title, content container, button container and tail )
 142   CreateDialog();
 143
 144   mLayer.Add( self );
 145
 146   mPopupLayout = Toolkit::TableView::New( 3, 1 );
 147   mPopupLayout.SetName( "POPUP_LAYOUT_TABLE" );
 148   mPopupLayout.SetParentOrigin(ParentOrigin::CENTER);
 149   mPopupLayout.SetAnchorPoint(AnchorPoint::CENTER);
 150   mPopupLayout.SetResizePolicy( FILL_TO_PARENT, WIDTH );
 151   mPopupLayout.SetResizePolicy( USE_NATURAL_SIZE, HEIGHT );
 152   mPopupLayout.SetFitHeight( 0 );   // Set row to fit
 153   mPopupLayout.SetFitHeight( 1 );   // Set row to fit
 154   self.Add( mPopupLayout );
 155
 156   // Any content after this point which is added to Self() will be reparented to
 157   // mContent.
 158   mAlterAddedChild = true;
 159
 160   // Default content.
 161 //  ShowTail(ParentOrigin::BOTTOM_CENTER);
 162
 163   // Hide content by default.
 164   SetState( Toolkit::Popup::POPUP_HIDE, 0.0f );
 165
 166   mPropertyTitle = self.RegisterProperty( PROPERTY_TITLE, "", Property::READ_WRITE );
 167   mPropertyState = self.RegisterProperty( PROPERTY_STATE, "POPUP_HIDE", Property::READ_WRITE );
 168
 169   // Make self as keyboard focusable and focus group
 170   self.SetKeyboardFocusable(true);
 171   SetAsKeyboardFocusGroup(true);
 172 }
 173
 174 void Popup::MarkDirtyForRelayout()
 175 {
 176   // Flag all the popup controls for relayout as it is about to be hidden and miss the main flagging pass
 177   mLayer.RelayoutRequestTree();
 178 }
 179
 180 void Popup::OnPropertySet( Property::Index index, Property::Value propertyValue )
 181 {
 182   if( index == mPropertyTitle )
 183   {
 184     SetTitle(propertyValue.Get<std::string>());
 185   }
 186   else if ( index == mPropertyState )
 187   {
 188     std::string value( propertyValue.Get<std::string>() );
 189     if(value == "POPUP_SHOW")
 190     {
 191       SetState( Toolkit::Popup::POPUP_SHOW, 0.0f );
 192     }
 193     else if( value == "POPUP_HIDE")
 194     {
 195       SetState( Toolkit::Popup::POPUP_HIDE, 0.0f );
 196     }
 197   }
 198 }
 199
 200 Popup::~Popup()
 201 {
 202   mLayer.Unparent();
 203 }
 204
 205 size_t Popup::GetButtonCount() const
 206 {
 207   return mButtons.size();
 208 }
 209
 210 void Popup::SetBackgroundImage( Actor image )
 211 {
 212   // Removes any previous background.
 213   if( mBackgroundImage && mPopupLayout )
 214   {
 215     mPopupLayout.Remove( mBackgroundImage );
 216   }
 217
 218   // Adds new background to the dialog.
 219   mBackgroundImage = image;
 220
 221   mBackgroundImage.SetName( "POPUP_BACKGROUND_IMAGE" );
 222
 223   // OnDialogTouched only consume the event. It prevents the touch event to be caught by the backing.
 224   mBackgroundImage.TouchedSignal().Connect( this, &Popup::OnDialogTouched );
 225
 226   mBackgroundImage.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 227   mBackgroundImage.SetAnchorPoint( AnchorPoint::CENTER );
 228   mBackgroundImage.SetParentOrigin( ParentOrigin::CENTER );
 229
 230   mBackgroundImage.SetSizeMode( SIZE_FIXED_OFFSET_FROM_PARENT );
 231   Vector3 border( mPopupStyle->backgroundOuterBorder.x, mPopupStyle->backgroundOuterBorder.z, 0.0f );
 232   mBackgroundImage.SetSizeModeFactor( border );
 233
 234   const bool prevAlter = mAlterAddedChild;
 235   mAlterAddedChild = false;
 236   Self().Add( mBackgroundImage );
 237   mAlterAddedChild = prevAlter;
 238 }
 239
 240 void Popup::SetButtonAreaImage( Actor image )
 241 {
 242   // Removes any previous area image.
 243   if( mButtonAreaImage && mPopupLayout )
 244   {
 245     mPopupLayout.Remove( mButtonAreaImage );
 246   }
 247
 248   // Adds new area image to the dialog.
 249   mButtonAreaImage = image;
 250
 251   // OnDialogTouched only consume the event. It prevents the touch event to be caught by the backing.
 252   mButtonAreaImage.TouchedSignal().Connect( this, &Popup::OnDialogTouched );
 253
 254   mButtonAreaImage.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 255   mButtonAreaImage.SetAnchorPoint( AnchorPoint::CENTER );
 256   mButtonAreaImage.SetParentOrigin( ParentOrigin::CENTER );
 257
 258   if( GetButtonCount() > 0 )
 259   {
 260     mBottomBg.Add( mButtonAreaImage );
 261   }
 262 }
 263
 264 void Popup::SetTitle( const std::string& text )
 265 {
 266   Toolkit::TextView titleActor = Toolkit::TextView::New();
 267   titleActor.SetName( "POPUP_TITLE" );
 268   titleActor.SetText( text );
 269   titleActor.SetColor( Color::BLACK );
 270   titleActor.SetMultilinePolicy( Toolkit::TextView::SplitByWord );
 271   titleActor.SetWidthExceedPolicy( Toolkit::TextView::Split );
 272   titleActor.SetLineJustification( Toolkit::TextView::Center );
 273
 274   SetTitle( titleActor );
 275 }
 276
 277 void Popup::SetTitle( Toolkit::TextView titleActor )
 278 {
 279   // Replaces the current title actor.
 280   if( mPopupLayout )
 281   {
 282     mPopupLayout.RemoveChildAt( Toolkit::TableView::CellPosition( 0, 0 ) );
 283   }
 284
 285   mTitle = titleActor;
 286
 287   if( mPopupLayout )
 288   {
 289     mTitle.SetPadding( Padding( 0.0f, 0.0f, mPopupStyle->margin, mPopupStyle->margin ) );
 290     mTitle.SetResizePolicy( FILL_TO_PARENT, WIDTH );
 291     mTitle.SetDimensionDependency( HEIGHT, WIDTH ); // HeightForWidth
 292     mPopupLayout.AddChild( mTitle, Toolkit::TableView::CellPosition( 0, 0 ) );
 293   }
 294
 295   RelayoutRequest();
 296 }
 297
 298 Toolkit::TextView Popup::GetTitle() const
 299 {
 300   return mTitle;
 301 }
 302
 303 void Popup::CreateFooter()
 304 {
 305   if( !mBottomBg )
 306   {
 307     // Adds bottom background
 308     mBottomBg = Actor::New();
 309     mBottomBg.SetName( "POPUP_BOTTOM_BG" );
 310     mBottomBg.SetRelayoutEnabled( true );
 311     mBottomBg.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 312
 313     mPopupLayout.SetFixedHeight( 2, mPopupStyle->bottomSize.height );   // Buttons
 314     mPopupLayout.AddChild( mBottomBg, Toolkit::TableView::CellPosition( 2, 0 ) );
 315   }
 316 }
 317
 318 void Popup::AddButton( Toolkit::Button button )
 319 {
 320   mButtons.push_back( button );
 321   button.SetResizePolicy( USE_ASSIGNED_SIZE, ALL_DIMENSIONS );    // Size will be assigned to it
 322
 323   // If this is the first button added
 324   if( mButtons.size() == 1 )
 325   {
 326     CreateFooter();
 327
 328     if( mButtonAreaImage )
 329     {
 330       mBottomBg.Add( mButtonAreaImage );
 331     }
 332   }
 333
 334   mBottomBg.Add( button );
 335
 336   RelayoutRequest();
 337 }
 338
 339 void Popup::SetState( Toolkit::Popup::PopupState state )
 340 {
 341   SetState( state, POPUP_ANIMATION_DURATION );
 342 }
 343
 344 void Popup::SetState( Toolkit::Popup::PopupState state, float duration )
 345 {
 346   // default animation behaviour.
 347   HandleStateChange(state, duration);
 348 }
 349
 350 Toolkit::Popup::PopupState Popup::GetState() const
 351 {
 352   return mState;
 353 }
 354
 355 void Popup::ShowTail(const Vector3& position)
 356 {
 357   // Replaces the tail actor.
 358   if(mTailImage && mTailImage.GetParent())
 359   {
 360     mTailImage.GetParent().Remove( mTailImage );
 361     mTailImage.Reset();
 362   }
 363
 364   std::string image = "";
 365
 366   // depending on position of tail around ParentOrigin, a different tail image is used...
 367   if(position.y < Math::MACHINE_EPSILON_1)
 368   {
 369     image = mPopupStyle->tailUpImage;
 370   }
 371   else if(position.y > 1.0f - Math::MACHINE_EPSILON_1)
 372   {
 373     image = mPopupStyle->tailDownImage;
 374   }
 375   else if(position.x < Math::MACHINE_EPSILON_1)
 376   {
 377     image = mPopupStyle->tailLeftImage;
 378   }
 379   else if(position.x > 1.0f - Math::MACHINE_EPSILON_1)
 380   {
 381     image = mPopupStyle->tailRightImage;
 382   }
 383
 384   if(image != "")
 385   {
 386     Image tail = ResourceImage::New( image );
 387     mTailImage = ImageActor::New(tail);
 388     const Vector3 anchorPoint = AnchorPoint::BOTTOM_RIGHT - position;
 389
 390     mTailImage.SetParentOrigin(position);
 391     mTailImage.SetAnchorPoint(anchorPoint);
 392
 393     CreateFooter();
 394
 395     mBottomBg.Add(mTailImage);
 396   }
 397 }
 398
 399 void Popup::HideTail()
 400 {
 401   ShowTail(ParentOrigin::CENTER);
 402 }
 403
 404 void Popup::SetStyle(PopupStyle& style)
 405 {
 406   mPopupStyle = PopupStylePtr(&style);
 407   // update //
 408 }
 409
 410 PopupStylePtr Popup::GetStyle() const
 411 {
 412   return mPopupStyle;
 413 }
 414
 415 void Popup::SetDefaultBackgroundImage()
 416 {
 417   Image buttonBg = ResourceImage::New( mPopupStyle->buttonAreaImage );
 418   ImageActor buttonBgImage = ImageActor::New( buttonBg );
 419   buttonBgImage.SetStyle( ImageActor::STYLE_NINE_PATCH );
 420   buttonBgImage.SetNinePatchBorder( mPopupStyle->buttonArea9PatchBorder );
 421
 422   SetBackgroundImage( ImageActor::New( ResourceImage::New( mPopupStyle->backgroundImage ) ) );
 423   SetButtonAreaImage( buttonBgImage );
 424 }
 425
 426 void Popup::CreateBacking()
 427 {
 428   mBacking = Dali::Toolkit::CreateSolidColorActor( mPopupStyle->backingColor );
 429   mBacking.SetName( "POPUP_BACKING" );
 430
 431   mBacking.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 432   mBacking.SetSensitive(true);
 433
 434   mLayer.Add( mBacking );
 435   mBacking.SetOpacity(0.0f);
 436   mBacking.TouchedSignal().Connect( this, &Popup::OnBackingTouched );
 437   mBacking.MouseWheelEventSignal().Connect(this, &Popup::OnBackingMouseWheelEvent);
 438 }
 439
 440 void Popup::CreateDialog()
 441 {
 442   // Adds default background image.
 443   SetDefaultBackgroundImage();
 444 }
 445
 446 void Popup::HandleStateChange( Toolkit::Popup::PopupState state, float duration )
 447 {
 448   Vector3 targetSize;
 449   float targetBackingAlpha;
 450
 451   if(mState == state)
 452   {
 453     return;
 454   }
 455   mState = state;
 456   switch(state)
 457   {
 458     case Toolkit::Popup::POPUP_HIDE:
 459     {
 460       targetSize = Vector3(0.0f, 0.0f, 1.0f);
 461       targetBackingAlpha = 0.0f;
 462       mShowing = false;
 463       ClearKeyInputFocus();
 464
 465       // Retore the keyboard focus when popup is hidden
 466       if(mPreviousFocusedActor && mPreviousFocusedActor.IsKeyboardFocusable() )
 467       {
 468         Dali::Toolkit::KeyboardFocusManager keyboardFocusManager = Dali::Toolkit::KeyboardFocusManager::Get();
 469         if( keyboardFocusManager )
 470         {
 471           keyboardFocusManager.SetCurrentFocusActor(mPreviousFocusedActor);
 472         }
 473       }
 474
 475       break;
 476     }
 477
 478     case Toolkit::Popup::POPUP_SHOW:
 479     default:
 480     {
 481       targetSize = Vector3(1.0f, 1.0f, 1.0f);
 482       targetBackingAlpha = 1.0f;
 483       mShowing = true;
 484
 485       // Add contents to stage for showing.
 486       if( !mLayer.GetParent() )
 487       {
 488         Dali::Stage stage = Dali::Stage::GetCurrent();
 489         stage.Add( mLayer );
 490         mLayer.RaiseToTop();
 491       }
 492
 493       Self().SetSensitive(true);
 494       SetKeyInputFocus();
 495
 496       // Handle the keyboard focus when popup is shown
 497       Dali::Toolkit::KeyboardFocusManager keyboardFocusManager = Dali::Toolkit::KeyboardFocusManager::Get();
 498       if( keyboardFocusManager )
 499       {
 500         mPreviousFocusedActor = keyboardFocusManager.GetCurrentFocusActor();
 501
 502         if( mContent && mContent.IsKeyboardFocusable() )
 503         {
 504           // If content is focusable, move the focus to content
 505           keyboardFocusManager.SetCurrentFocusActor(mContent);
 506         }
 507         else if( !mButtons.empty() )
 508         {
 509           // Otherwise, movethe focus to the first button
 510           keyboardFocusManager.SetCurrentFocusActor(mButtons[0]);
 511         }
 512         else
 513         {
 514           DALI_LOG_WARNING("There is no focusable in popup\n");
 515         }
 516       }
 517       break;
 518     }
 519   }
 520
 521   Actor self = Self();
 522   if(duration > Math::MACHINE_EPSILON_1)
 523   {
 524     if ( mAnimation )
 525     {
 526       mAnimation.Stop();
 527       mAnimation.Clear();
 528       mAnimation.Reset();
 529     }
 530     mAnimation = Animation::New(duration);
 531
 532     if(mShowing)
 533     {
 534       mAnimation.AnimateTo( Property(mBacking, Actor::Property::COLOR_ALPHA), targetBackingAlpha, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 535       mAnimation.AnimateTo( Property(self, Actor::Property::SCALE), targetSize, AlphaFunctions::EaseInOut, TimePeriod(duration * 0.5f, duration * 0.5f) );
 536     }
 537     else
 538     {
 539       mAnimation.AnimateTo( Property(mBacking, Actor::Property::COLOR_ALPHA), targetBackingAlpha, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 540       mAnimation.AnimateTo( Property(self, Actor::Property::SCALE), targetSize, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 541     }
 542     mAnimation.Play();
 543     mAnimation.FinishedSignal().Connect(this, &Popup::OnStateAnimationFinished);
 544   }
 545   else
 546   {
 547     mBacking.SetOpacity( targetBackingAlpha );
 548     self.SetScale( targetSize );
 549
 550     HandleStateChangeComplete();
 551   }
 552 }
 553
 554 void Popup::HandleStateChangeComplete()
 555 {
 556   // Remove contents from stage if completely hidden.
 557   if( ( mState == Toolkit::Popup::POPUP_HIDE ) && mLayer.GetParent() )
 558   {
 559     mLayer.Unparent();
 560     Self().SetSensitive( false );
 561
 562     // Guard against destruction during signal emission
 563     Toolkit::Popup handle( GetOwner() );
 564     mHiddenSignal.Emit();
 565   }
 566 }
 567
 568 Toolkit::Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
 569 {
 570   return mTouchedOutsideSignal;
 571 }
 572
 573 Toolkit::Popup::HiddenSignalType& Popup::HiddenSignal()
 574 {
 575   return mHiddenSignal;
 576 }
 577
 578 bool Popup::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 579 {
 580   Dali::BaseHandle handle( object );
 581
 582   bool connected( true );
 583   Toolkit::Popup popup = Toolkit::Popup::DownCast( handle );
 584
 585   if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED_OUTSIDE ) )
 586   {
 587     popup.OutsideTouchedSignal().Connect( tracker, functor );
 588   }
 589   else if( 0 == strcmp( signalName.c_str(), SIGNAL_HIDDEN ) )
 590   {
 591     popup.HiddenSignal().Connect( tracker, functor );
 592   }
 593   else
 594   {
 595     // signalName does not match any signal
 596     connected = false;
 597   }
 598
 599   return connected;
 600 }
 601
 602 void Popup::OnStateAnimationFinished( Animation& source )
 603 {
 604   HandleStateChangeComplete();
 605 }
 606
 607 bool Popup::OnBackingTouched(Actor actor, const TouchEvent& event)
 608 {
 609   if(event.GetPointCount()>0)
 610   {
 611     const TouchPoint& point = event.GetPoint(0);
 612
 613     if(point.state == TouchPoint::Down)
 614     {
 615       // Guard against destruction during signal emission
 616       Toolkit::Popup handle( GetOwner() );
 617
 618       mTouchedOutsideSignal.Emit();
 619     }
 620   }
 621
 622   return true;
 623 }
 624
 625 bool Popup::OnBackingMouseWheelEvent(Actor actor, const MouseWheelEvent& event)
 626 {
 627   // consume mouse wheel event in dimmed backing actor
 628   return true;
 629 }
 630
 631 bool Popup::OnDialogTouched(Actor actor, const TouchEvent& event)
 632 {
 633   // consume event (stops backing actor receiving touch events)
 634   return true;
 635 }
 636
 637 void Popup::OnControlChildAdd( Actor& child )
 638 {
 639   // reparent any children added by user to the body layer.
 640   if( mAlterAddedChild )
 641   {
 642     // Removes previously added content.
 643     if( mContent )
 644     {
 645       mPopupLayout.RemoveChildAt( Toolkit::TableView::CellPosition( 1, 0 ) );
 646     }
 647
 648     // keep a handle to the new content.
 649     mContent = child;
 650
 651     mPopupLayout.AddChild( mContent, Toolkit::TableView::CellPosition( 1, 0 ) );
 652   }
 653 }
 654
 655 void Popup::OnRelayout( const Vector2& size, RelayoutContainer& container )
 656 {
 657   // Hide the background image
 658   mBackgroundImage.SetVisible( !( mButtons.empty() && mPopupLayout.GetChildCount() == 0 ) );
 659
 660   // Relayout All buttons
 661   if ( !mButtons.empty() )
 662   {
 663     // All buttons should be the same size and fill the button area. The button spacing needs to be accounted for as well.
 664     Vector2 buttonSize( ( ( size.width - mPopupStyle->buttonSpacing * ( mButtons.size() + 1 ) ) / mButtons.size() ),
 665                         mPopupStyle->bottomSize.height - mPopupStyle->margin );
 666
 667     Vector3 buttonPosition( mPopupStyle->buttonSpacing, 0.0f, 0.0f );
 668
 669     for ( ActorIter iter = mButtons.begin(), endIter = mButtons.end();
 670           iter != endIter;
 671           ++iter, buttonPosition.x += mPopupStyle->buttonSpacing + buttonSize.width )
 672     {
 673       Actor button = *iter;
 674
 675       // If there is only one button, it needs to be laid out on center.
 676       if ( mButtons.size() == 1 )
 677       {
 678         buttonPosition.x = 0.0f;
 679         button.SetAnchorPoint( AnchorPoint::CENTER );
 680         button.SetParentOrigin( ParentOrigin::CENTER );
 681       }
 682       else
 683       {
 684         button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 685         button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 686       }
 687
 688       button.SetPosition( buttonPosition );
 689
 690       button.PropagateRelayoutFlags();    // Reset relayout flags for relayout
 691       container.Add( button, buttonSize );
 692     }
 693   }
 694 }
 695
 696 void Popup::OnSetResizePolicy( ResizePolicy policy, Dimension dimension )
 697 {
 698   if( mPopupLayout )
 699   {
 700     if( policy == FIT_TO_CHILDREN )
 701     {
 702       mPopupLayout.SetResizePolicy( USE_NATURAL_SIZE, dimension );
 703       if( dimension & HEIGHT )
 704       {
 705         mPopupLayout.SetFitHeight( 1 );
 706       }
 707     }
 708     else
 709     {
 710       mPopupLayout.SetResizePolicy( FILL_TO_PARENT, dimension );
 711       // Make the content cell fill the whole of the available space
 712       if( dimension & HEIGHT )
 713       {
 714         mPopupLayout.SetRelativeHeight( 1, 1.0f );
 715       }
 716     }
 717   }
 718 }
 719
 720 bool Popup::OnKeyEvent(const KeyEvent& event)
 721 {
 722   bool consumed = false;
 723
 724   if(event.state == KeyEvent::Down)
 725   {
 726     if (event.keyCode == Dali::DALI_KEY_ESCAPE || event.keyCode == Dali::DALI_KEY_BACK)
 727     {
 728       SetState(Toolkit::Popup::POPUP_HIDE);
 729       consumed = true;
 730     }
 731   }
 732
 733   return consumed;
 734 }
 735
 736 Vector3 Popup::GetNaturalSize()
 737 {
 738   float margin = 2.0f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin );
 739   const float maxWidth = Stage::GetCurrent().GetSize().width - margin;
 740
 741   Vector3 naturalSize( 0.0f, 0.0f, 0.0f );
 742
 743   if ( mTitle )
 744   {
 745     Vector3 titleNaturalSize = mTitle.GetImplementation().GetNaturalSize();
 746     // Buffer to avoid errors. The width of the popup could potentially be the width of the title text.
 747     // It was observed in this case that text wrapping was then inconsistent when seen on device
 748     const float titleBuffer = 0.5f;
 749     titleNaturalSize.width += titleBuffer;
 750
 751     // As TextView GetNaturalSize does not take wrapping into account, limit the width
 752     // to that of the stage
 753     if( titleNaturalSize.width >= maxWidth)
 754     {
 755       naturalSize.width = maxWidth;
 756       naturalSize.height = mTitle.GetImplementation().GetHeightForWidth( naturalSize.width );
 757     }
 758     else
 759     {
 760       naturalSize += titleNaturalSize;
 761     }
 762
 763     naturalSize.height += mPopupStyle->margin;
 764   }
 765
 766   if( mContent )
 767   {
 768     Vector3 contentSize = mContent.GetNaturalSize();
 769     // Choose the biggest width
 770     naturalSize.width = std::max( naturalSize.width, contentSize.width );
 771     if( naturalSize.width > maxWidth )
 772     {
 773       naturalSize.width = maxWidth;
 774       contentSize.height = mContent.GetHeightForWidth( maxWidth );
 775     }
 776     naturalSize.height += contentSize.height + mPopupStyle->margin;
 777   }
 778
 779   if( !mButtons.empty() )
 780   {
 781     naturalSize.height += mPopupStyle->bottomSize.height;
 782   }
 783
 784   // Add the margins
 785   naturalSize.width += margin;
 786   naturalSize.height += margin;
 787
 788   return naturalSize;
 789 }
 790
 791 float Popup::GetHeightForWidth( float width )
 792 {
 793   float height( 0.0f );
 794   float popupWidth( width - 2.f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin ) );
 795
 796   if ( mTitle )
 797   {
 798     height += mTitle.GetImplementation().GetHeightForWidth( popupWidth );
 799     height += mPopupStyle->margin;
 800   }
 801
 802   if( mContent )
 803   {
 804     height += mContent.GetHeightForWidth( popupWidth ) + mPopupStyle->margin;
 805   }
 806
 807   if( !mButtons.empty() )
 808   {
 809     height += mPopupStyle->bottomSize.height;
 810   }
 811
 812   // Add the margins
 813   float margin( 2.0f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin ) );
 814   height += margin;
 815
 816   return height;
 817 }
 818
 819 float Popup::GetWidthForHeight( float height )
 820 {
 821   return GetNaturalSize().width;
 822 }
 823
 824 Actor Popup::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 825 {
 826   Actor nextFocusableActor( currentFocusedActor );
 827
 828   // TODO: Needs to be optimised
 829
 830   if ( !currentFocusedActor || ( currentFocusedActor && KeyboardFocusManager::Get().GetFocusGroup(currentFocusedActor) != Self() ) )
 831   {
 832     // The current focused actor is not within popup
 833     if( mContent && mContent.IsKeyboardFocusable() )
 834     {
 835       // If content is focusable, move the focus to content
 836       nextFocusableActor = mContent;
 837     }
 838     else if( !mButtons.empty() )
 839     {
 840       // Otherwise, movethe focus to the first button
 841       nextFocusableActor = mButtons[0];
 842     }
 843   }
 844   else
 845   {
 846     // Rebuild the focus chain because button or content can be added or removed dynamically
 847     ActorContainer focusableActors;
 848     if( mContent && mContent.IsKeyboardFocusable() )
 849     {
 850       focusableActors.push_back(mContent);
 851     }
 852
 853     for(unsigned int i = 0; i < mButtons.size(); i++)
 854     {
 855       if( mButtons[i] && mButtons[i].IsKeyboardFocusable() )
 856       {
 857         focusableActors.push_back(mButtons[i]);
 858       }
 859     }
 860
 861     for ( ActorContainer::iterator iter = focusableActors.begin(), end = focusableActors.end(); iter != end; ++iter )
 862     {
 863       if ( currentFocusedActor == *iter )
 864       {
 865         switch ( direction )
 866         {
 867           case Toolkit::Control::Left:
 868           {
 869             if ( iter == focusableActors.begin() )
 870             {
 871               nextFocusableActor = *( focusableActors.end() - 1 );
 872             }
 873             else
 874             {
 875               nextFocusableActor = *( iter - 1 );
 876             }
 877             break;
 878           }
 879           case Toolkit::Control::Right:
 880           {
 881             if ( iter == focusableActors.end() - 1 )
 882             {
 883               nextFocusableActor = *( focusableActors.begin() );
 884             }
 885             else
 886             {
 887               nextFocusableActor = *( iter + 1 );
 888             }
 889             break;
 890           }
 891
 892           case Toolkit::Control::Up:
 893           {
 894             if ( *iter == mContent )
 895             {
 896               nextFocusableActor = *( focusableActors.end() - 1 );
 897             }
 898             else
 899             {
 900               if ( mContent && mContent.IsKeyboardFocusable() )
 901               {
 902                 nextFocusableActor = mContent;
 903               }
 904               else
 905               {
 906                 if ( iter == focusableActors.begin() )
 907                 {
 908                   nextFocusableActor = *( focusableActors.end() - 1 );
 909                 }
 910                 else
 911                 {
 912                   nextFocusableActor = *( iter - 1 );
 913                 }
 914               }
 915             }
 916             break;
 917           }
 918
 919           case Toolkit::Control::Down:
 920           {
 921             if ( mContent && mContent.IsKeyboardFocusable() )
 922             {
 923               nextFocusableActor = mContent;
 924             }
 925             else
 926             {
 927               if ( iter == focusableActors.end() - 1 )
 928               {
 929                 nextFocusableActor = *( focusableActors.begin() );
 930               }
 931               else
 932               {
 933                 nextFocusableActor = *( iter + 1 );
 934               }
 935             }
 936
 937             if ( *iter == mContent && !mButtons.empty() )
 938             {
 939               nextFocusableActor = mButtons[0];
 940             }
 941             break;
 942           }
 943         }
 944
 945         if(!nextFocusableActor)
 946         {
 947           DALI_LOG_WARNING("Can not decide next focusable actor\n");
 948         }
 949
 950         break;
 951       }
 952     }
 953   }
 954
 955   return nextFocusableActor;
 956 }
 957
 958 } // namespace Internal
 959
 960 } // namespace Toolkit
 961
 962 } // namespace Dali