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( SIZE_FIXED_OFFSET_FROM_PARENT, ALL_DIMENSIONS );
 227   mBackgroundImage.SetAnchorPoint( AnchorPoint::CENTER );
 228   mBackgroundImage.SetParentOrigin( ParentOrigin::CENTER );
 229
 230   Vector3 border( mPopupStyle->backgroundOuterBorder.x, mPopupStyle->backgroundOuterBorder.z, 0.0f );
 231   mBackgroundImage.SetSizeModeFactor( border );
 232
 233   const bool prevAlter = mAlterAddedChild;
 234   mAlterAddedChild = false;
 235   Self().Add( mBackgroundImage );
 236   mAlterAddedChild = prevAlter;
 237 }
 238
 239 void Popup::SetButtonAreaImage( Actor image )
 240 {
 241   // Removes any previous area image.
 242   if( mButtonAreaImage && mPopupLayout )
 243   {
 244     mPopupLayout.Remove( mButtonAreaImage );
 245   }
 246
 247   // Adds new area image to the dialog.
 248   mButtonAreaImage = image;
 249
 250   // OnDialogTouched only consume the event. It prevents the touch event to be caught by the backing.
 251   mButtonAreaImage.TouchedSignal().Connect( this, &Popup::OnDialogTouched );
 252
 253   mButtonAreaImage.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 254   mButtonAreaImage.SetAnchorPoint( AnchorPoint::CENTER );
 255   mButtonAreaImage.SetParentOrigin( ParentOrigin::CENTER );
 256
 257   if( GetButtonCount() > 0 )
 258   {
 259     mBottomBg.Add( mButtonAreaImage );
 260   }
 261 }
 262
 263 void Popup::SetTitle( const std::string& text )
 264 {
 265   // Replaces the current title actor.
 266   if( mPopupLayout )
 267   {
 268     mPopupLayout.RemoveChildAt( Toolkit::TableView::CellPosition( 0, 0 ) );
 269   }
 270
 271   mTitle = Toolkit::TextLabel::New( text );
 272   mTitle.SetName( "POPUP_TITLE" );
 273   mTitle.SetProperty( Toolkit::TextLabel::Property::MULTI_LINE, true );
 274   mTitle.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 275
 276   if( mPopupLayout )
 277   {
 278     mTitle.SetPadding( Padding( 0.0f, 0.0f, mPopupStyle->margin, mPopupStyle->margin ) );
 279     mTitle.SetResizePolicy( FILL_TO_PARENT, WIDTH );
 280     mTitle.SetResizePolicy( DIMENSION_DEPENDENCY, HEIGHT );
 281     mPopupLayout.AddChild( mTitle, Toolkit::TableView::CellPosition( 0, 0 ) );
 282   }
 283
 284   RelayoutRequest();
 285 }
 286
 287 std::string Popup::GetTitle() const
 288 {
 289   if( mTitle )
 290   {
 291     return mTitle.GetProperty<std::string>( Toolkit::TextLabel::Property::TEXT );
 292   }
 293
 294   return std::string();
 295 }
 296
 297 void Popup::CreateFooter()
 298 {
 299   if( !mBottomBg )
 300   {
 301     // Adds bottom background
 302     mBottomBg = Actor::New();
 303     mBottomBg.SetName( "POPUP_BOTTOM_BG" );
 304     mBottomBg.SetRelayoutEnabled( true );
 305     mBottomBg.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 306
 307     mPopupLayout.SetFixedHeight( 2, mPopupStyle->bottomSize.height );   // Buttons
 308     mPopupLayout.AddChild( mBottomBg, Toolkit::TableView::CellPosition( 2, 0 ) );
 309   }
 310 }
 311
 312 void Popup::AddButton( Toolkit::Button button )
 313 {
 314   mButtons.push_back( button );
 315   button.SetResizePolicy( USE_ASSIGNED_SIZE, ALL_DIMENSIONS );    // Size will be assigned to it
 316
 317   // If this is the first button added
 318   if( mButtons.size() == 1 )
 319   {
 320     CreateFooter();
 321
 322     if( mButtonAreaImage )
 323     {
 324       mBottomBg.Add( mButtonAreaImage );
 325     }
 326   }
 327
 328   mBottomBg.Add( button );
 329
 330   RelayoutRequest();
 331 }
 332
 333 void Popup::SetState( Toolkit::Popup::PopupState state )
 334 {
 335   SetState( state, POPUP_ANIMATION_DURATION );
 336 }
 337
 338 void Popup::SetState( Toolkit::Popup::PopupState state, float duration )
 339 {
 340   // default animation behaviour.
 341   HandleStateChange(state, duration);
 342 }
 343
 344 Toolkit::Popup::PopupState Popup::GetState() const
 345 {
 346   return mState;
 347 }
 348
 349 void Popup::ShowTail(const Vector3& position)
 350 {
 351   // Replaces the tail actor.
 352   if(mTailImage && mTailImage.GetParent())
 353   {
 354     mTailImage.GetParent().Remove( mTailImage );
 355     mTailImage.Reset();
 356   }
 357
 358   std::string image = "";
 359
 360   // depending on position of tail around ParentOrigin, a different tail image is used...
 361   if(position.y < Math::MACHINE_EPSILON_1)
 362   {
 363     image = mPopupStyle->tailUpImage;
 364   }
 365   else if(position.y > 1.0f - Math::MACHINE_EPSILON_1)
 366   {
 367     image = mPopupStyle->tailDownImage;
 368   }
 369   else if(position.x < Math::MACHINE_EPSILON_1)
 370   {
 371     image = mPopupStyle->tailLeftImage;
 372   }
 373   else if(position.x > 1.0f - Math::MACHINE_EPSILON_1)
 374   {
 375     image = mPopupStyle->tailRightImage;
 376   }
 377
 378   if(image != "")
 379   {
 380     Image tail = ResourceImage::New( image );
 381     mTailImage = ImageActor::New(tail);
 382     const Vector3 anchorPoint = AnchorPoint::BOTTOM_RIGHT - position;
 383
 384     mTailImage.SetParentOrigin(position);
 385     mTailImage.SetAnchorPoint(anchorPoint);
 386
 387     CreateFooter();
 388
 389     mBottomBg.Add(mTailImage);
 390   }
 391 }
 392
 393 void Popup::HideTail()
 394 {
 395   ShowTail(ParentOrigin::CENTER);
 396 }
 397
 398 void Popup::SetStyle(PopupStyle& style)
 399 {
 400   mPopupStyle = PopupStylePtr(&style);
 401   // update //
 402 }
 403
 404 PopupStylePtr Popup::GetStyle() const
 405 {
 406   return mPopupStyle;
 407 }
 408
 409 void Popup::SetDefaultBackgroundImage()
 410 {
 411   Image buttonBg = ResourceImage::New( mPopupStyle->buttonAreaImage );
 412   ImageActor buttonBgImage = ImageActor::New( buttonBg );
 413   buttonBgImage.SetStyle( ImageActor::STYLE_NINE_PATCH );
 414   buttonBgImage.SetNinePatchBorder( mPopupStyle->buttonArea9PatchBorder );
 415
 416   SetBackgroundImage( ImageActor::New( ResourceImage::New( mPopupStyle->backgroundImage ) ) );
 417   SetButtonAreaImage( buttonBgImage );
 418 }
 419
 420 void Popup::CreateBacking()
 421 {
 422   mBacking = Dali::Toolkit::CreateSolidColorActor( mPopupStyle->backingColor );
 423   mBacking.SetName( "POPUP_BACKING" );
 424
 425   mBacking.SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 426   mBacking.SetSensitive(true);
 427
 428   mLayer.Add( mBacking );
 429   mBacking.SetOpacity(0.0f);
 430   mBacking.TouchedSignal().Connect( this, &Popup::OnBackingTouched );
 431   mBacking.MouseWheelEventSignal().Connect(this, &Popup::OnBackingMouseWheelEvent);
 432 }
 433
 434 void Popup::CreateDialog()
 435 {
 436   // Adds default background image.
 437   SetDefaultBackgroundImage();
 438 }
 439
 440 void Popup::HandleStateChange( Toolkit::Popup::PopupState state, float duration )
 441 {
 442   Vector3 targetSize;
 443   float targetBackingAlpha;
 444
 445   if(mState == state)
 446   {
 447     return;
 448   }
 449   mState = state;
 450   switch(state)
 451   {
 452     case Toolkit::Popup::POPUP_HIDE:
 453     {
 454       targetSize = Vector3(0.0f, 0.0f, 1.0f);
 455       targetBackingAlpha = 0.0f;
 456       mShowing = false;
 457       ClearKeyInputFocus();
 458
 459       // Retore the keyboard focus when popup is hidden
 460       if(mPreviousFocusedActor && mPreviousFocusedActor.IsKeyboardFocusable() )
 461       {
 462         Dali::Toolkit::KeyboardFocusManager keyboardFocusManager = Dali::Toolkit::KeyboardFocusManager::Get();
 463         if( keyboardFocusManager )
 464         {
 465           keyboardFocusManager.SetCurrentFocusActor(mPreviousFocusedActor);
 466         }
 467       }
 468
 469       break;
 470     }
 471
 472     case Toolkit::Popup::POPUP_SHOW:
 473     default:
 474     {
 475       targetSize = Vector3(1.0f, 1.0f, 1.0f);
 476       targetBackingAlpha = 1.0f;
 477       mShowing = true;
 478
 479       // Add contents to stage for showing.
 480       if( !mLayer.GetParent() )
 481       {
 482         Dali::Stage stage = Dali::Stage::GetCurrent();
 483         stage.Add( mLayer );
 484         mLayer.RaiseToTop();
 485       }
 486
 487       Self().SetSensitive(true);
 488       SetKeyInputFocus();
 489
 490       // Handle the keyboard focus when popup is shown
 491       Dali::Toolkit::KeyboardFocusManager keyboardFocusManager = Dali::Toolkit::KeyboardFocusManager::Get();
 492       if( keyboardFocusManager )
 493       {
 494         mPreviousFocusedActor = keyboardFocusManager.GetCurrentFocusActor();
 495
 496         if( mContent && mContent.IsKeyboardFocusable() )
 497         {
 498           // If content is focusable, move the focus to content
 499           keyboardFocusManager.SetCurrentFocusActor(mContent);
 500         }
 501         else if( !mButtons.empty() )
 502         {
 503           // Otherwise, movethe focus to the first button
 504           keyboardFocusManager.SetCurrentFocusActor(mButtons[0]);
 505         }
 506         else
 507         {
 508           DALI_LOG_WARNING("There is no focusable in popup\n");
 509         }
 510       }
 511       break;
 512     }
 513   }
 514
 515   Actor self = Self();
 516   if(duration > Math::MACHINE_EPSILON_1)
 517   {
 518     if ( mAnimation )
 519     {
 520       mAnimation.Stop();
 521       mAnimation.Clear();
 522       mAnimation.Reset();
 523     }
 524     mAnimation = Animation::New(duration);
 525
 526     if(mShowing)
 527     {
 528       mAnimation.AnimateTo( Property(mBacking, Actor::Property::COLOR_ALPHA), targetBackingAlpha, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 529       mAnimation.AnimateTo( Property(self, Actor::Property::SCALE), targetSize, AlphaFunctions::EaseInOut, TimePeriod(duration * 0.5f, duration * 0.5f) );
 530     }
 531     else
 532     {
 533       mAnimation.AnimateTo( Property(mBacking, Actor::Property::COLOR_ALPHA), targetBackingAlpha, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 534       mAnimation.AnimateTo( Property(self, Actor::Property::SCALE), targetSize, AlphaFunctions::EaseInOut, TimePeriod(0.0f, duration * 0.5f) );
 535     }
 536     mAnimation.Play();
 537     mAnimation.FinishedSignal().Connect(this, &Popup::OnStateAnimationFinished);
 538   }
 539   else
 540   {
 541     mBacking.SetOpacity( targetBackingAlpha );
 542     self.SetScale( targetSize );
 543
 544     HandleStateChangeComplete();
 545   }
 546 }
 547
 548 void Popup::HandleStateChangeComplete()
 549 {
 550   // Remove contents from stage if completely hidden.
 551   if( ( mState == Toolkit::Popup::POPUP_HIDE ) && mLayer.GetParent() )
 552   {
 553     mLayer.Unparent();
 554     Self().SetSensitive( false );
 555
 556     // Guard against destruction during signal emission
 557     Toolkit::Popup handle( GetOwner() );
 558     mHiddenSignal.Emit();
 559   }
 560 }
 561
 562 Toolkit::Popup::TouchedOutsideSignalType& Popup::OutsideTouchedSignal()
 563 {
 564   return mTouchedOutsideSignal;
 565 }
 566
 567 Toolkit::Popup::HiddenSignalType& Popup::HiddenSignal()
 568 {
 569   return mHiddenSignal;
 570 }
 571
 572 bool Popup::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 573 {
 574   Dali::BaseHandle handle( object );
 575
 576   bool connected( true );
 577   Toolkit::Popup popup = Toolkit::Popup::DownCast( handle );
 578
 579   if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED_OUTSIDE ) )
 580   {
 581     popup.OutsideTouchedSignal().Connect( tracker, functor );
 582   }
 583   else if( 0 == strcmp( signalName.c_str(), SIGNAL_HIDDEN ) )
 584   {
 585     popup.HiddenSignal().Connect( tracker, functor );
 586   }
 587   else
 588   {
 589     // signalName does not match any signal
 590     connected = false;
 591   }
 592
 593   return connected;
 594 }
 595
 596 void Popup::OnStateAnimationFinished( Animation& source )
 597 {
 598   HandleStateChangeComplete();
 599 }
 600
 601 bool Popup::OnBackingTouched(Actor actor, const TouchEvent& event)
 602 {
 603   if(event.GetPointCount()>0)
 604   {
 605     const TouchPoint& point = event.GetPoint(0);
 606
 607     if(point.state == TouchPoint::Down)
 608     {
 609       // Guard against destruction during signal emission
 610       Toolkit::Popup handle( GetOwner() );
 611
 612       mTouchedOutsideSignal.Emit();
 613     }
 614   }
 615
 616   return true;
 617 }
 618
 619 bool Popup::OnBackingMouseWheelEvent(Actor actor, const MouseWheelEvent& event)
 620 {
 621   // consume mouse wheel event in dimmed backing actor
 622   return true;
 623 }
 624
 625 bool Popup::OnDialogTouched(Actor actor, const TouchEvent& event)
 626 {
 627   // consume event (stops backing actor receiving touch events)
 628   return true;
 629 }
 630
 631 void Popup::OnControlChildAdd( Actor& child )
 632 {
 633   // reparent any children added by user to the body layer.
 634   if( mAlterAddedChild )
 635   {
 636     // Removes previously added content.
 637     if( mContent )
 638     {
 639       mPopupLayout.RemoveChildAt( Toolkit::TableView::CellPosition( 1, 0 ) );
 640     }
 641
 642     // keep a handle to the new content.
 643     mContent = child;
 644
 645     mPopupLayout.AddChild( mContent, Toolkit::TableView::CellPosition( 1, 0 ) );
 646   }
 647 }
 648
 649 void Popup::OnRelayout( const Vector2& size, RelayoutContainer& container )
 650 {
 651   // Hide the background image
 652   mBackgroundImage.SetVisible( !( mButtons.empty() && mPopupLayout.GetChildCount() == 0 ) );
 653
 654   // Relayout All buttons
 655   if ( !mButtons.empty() )
 656   {
 657     // All buttons should be the same size and fill the button area. The button spacing needs to be accounted for as well.
 658     Vector2 buttonSize( ( ( size.width - mPopupStyle->buttonSpacing * ( mButtons.size() + 1 ) ) / mButtons.size() ),
 659                         mPopupStyle->bottomSize.height - mPopupStyle->margin );
 660
 661     Vector3 buttonPosition( mPopupStyle->buttonSpacing, 0.0f, 0.0f );
 662
 663     for ( ActorIter iter = mButtons.begin(), endIter = mButtons.end();
 664           iter != endIter;
 665           ++iter, buttonPosition.x += mPopupStyle->buttonSpacing + buttonSize.width )
 666     {
 667       Actor button = *iter;
 668
 669       // If there is only one button, it needs to be laid out on center.
 670       if ( mButtons.size() == 1 )
 671       {
 672         buttonPosition.x = 0.0f;
 673         button.SetAnchorPoint( AnchorPoint::CENTER );
 674         button.SetParentOrigin( ParentOrigin::CENTER );
 675       }
 676       else
 677       {
 678         button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 679         button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 680       }
 681
 682       button.SetPosition( buttonPosition );
 683
 684       button.PropagateRelayoutFlags();    // Reset relayout flags for relayout
 685       container.Add( button, buttonSize );
 686     }
 687   }
 688 }
 689
 690 void Popup::OnSetResizePolicy( ResizePolicy policy, Dimension dimension )
 691 {
 692   if( mPopupLayout )
 693   {
 694     if( policy == FIT_TO_CHILDREN )
 695     {
 696       mPopupLayout.SetResizePolicy( USE_NATURAL_SIZE, dimension );
 697       if( dimension & HEIGHT )
 698       {
 699         mPopupLayout.SetFitHeight( 1 );
 700       }
 701     }
 702     else
 703     {
 704       mPopupLayout.SetResizePolicy( FILL_TO_PARENT, dimension );
 705       // Make the content cell fill the whole of the available space
 706       if( dimension & HEIGHT )
 707       {
 708         mPopupLayout.SetRelativeHeight( 1, 1.0f );
 709       }
 710     }
 711   }
 712 }
 713
 714 bool Popup::OnKeyEvent(const KeyEvent& event)
 715 {
 716   bool consumed = false;
 717
 718   if(event.state == KeyEvent::Down)
 719   {
 720     if (event.keyCode == Dali::DALI_KEY_ESCAPE || event.keyCode == Dali::DALI_KEY_BACK)
 721     {
 722       SetState(Toolkit::Popup::POPUP_HIDE);
 723       consumed = true;
 724     }
 725   }
 726
 727   return consumed;
 728 }
 729
 730 Vector3 Popup::GetNaturalSize()
 731 {
 732   float margin = 2.0f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin );
 733   const float maxWidth = Stage::GetCurrent().GetSize().width - margin;
 734
 735   Vector3 naturalSize( 0.0f, 0.0f, 0.0f );
 736
 737   if ( mTitle )
 738   {
 739     Vector3 titleNaturalSize = mTitle.GetImplementation().GetNaturalSize();
 740     // Buffer to avoid errors. The width of the popup could potentially be the width of the title text.
 741     // It was observed in this case that text wrapping was then inconsistent when seen on device
 742     const float titleBuffer = 0.5f;
 743     titleNaturalSize.width += titleBuffer;
 744
 745     // As TextLabel GetNaturalSize does not take wrapping into account, limit the width
 746     // to that of the stage
 747     if( titleNaturalSize.width >= maxWidth)
 748     {
 749       naturalSize.width = maxWidth;
 750       naturalSize.height = mTitle.GetImplementation().GetHeightForWidth( naturalSize.width );
 751     }
 752     else
 753     {
 754       naturalSize += titleNaturalSize;
 755     }
 756
 757     naturalSize.height += mPopupStyle->margin;
 758   }
 759
 760   if( mContent )
 761   {
 762     Vector3 contentSize = mContent.GetNaturalSize();
 763     // Choose the biggest width
 764     naturalSize.width = std::max( naturalSize.width, contentSize.width );
 765     if( naturalSize.width > maxWidth )
 766     {
 767       naturalSize.width = maxWidth;
 768       contentSize.height = mContent.GetHeightForWidth( maxWidth );
 769     }
 770     naturalSize.height += contentSize.height + mPopupStyle->margin;
 771   }
 772
 773   if( !mButtons.empty() )
 774   {
 775     naturalSize.height += mPopupStyle->bottomSize.height;
 776   }
 777
 778   // Add the margins
 779   naturalSize.width += margin;
 780   naturalSize.height += margin;
 781
 782   return naturalSize;
 783 }
 784
 785 float Popup::GetHeightForWidth( float width )
 786 {
 787   float height( 0.0f );
 788   float popupWidth( width - 2.f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin ) );
 789
 790   if ( mTitle )
 791   {
 792     height += mTitle.GetImplementation().GetHeightForWidth( popupWidth );
 793     height += mPopupStyle->margin;
 794   }
 795
 796   if( mContent )
 797   {
 798     height += mContent.GetHeightForWidth( popupWidth ) + mPopupStyle->margin;
 799   }
 800
 801   if( !mButtons.empty() )
 802   {
 803     height += mPopupStyle->bottomSize.height;
 804   }
 805
 806   // Add the margins
 807   float margin( 2.0f * ( POPUP_OUT_MARGIN_WIDTH + mPopupStyle->margin ) );
 808   height += margin;
 809
 810   return height;
 811 }
 812
 813 float Popup::GetWidthForHeight( float height )
 814 {
 815   return GetNaturalSize().width;
 816 }
 817
 818 Actor Popup::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 819 {
 820   Actor nextFocusableActor( currentFocusedActor );
 821
 822   // TODO: Needs to be optimised
 823
 824   if ( !currentFocusedActor || ( currentFocusedActor && KeyboardFocusManager::Get().GetFocusGroup(currentFocusedActor) != Self() ) )
 825   {
 826     // The current focused actor is not within popup
 827     if( mContent && mContent.IsKeyboardFocusable() )
 828     {
 829       // If content is focusable, move the focus to content
 830       nextFocusableActor = mContent;
 831     }
 832     else if( !mButtons.empty() )
 833     {
 834       // Otherwise, movethe focus to the first button
 835       nextFocusableActor = mButtons[0];
 836     }
 837   }
 838   else
 839   {
 840     // Rebuild the focus chain because button or content can be added or removed dynamically
 841     ActorContainer focusableActors;
 842     if( mContent && mContent.IsKeyboardFocusable() )
 843     {
 844       focusableActors.push_back(mContent);
 845     }
 846
 847     for(unsigned int i = 0; i < mButtons.size(); i++)
 848     {
 849       if( mButtons[i] && mButtons[i].IsKeyboardFocusable() )
 850       {
 851         focusableActors.push_back(mButtons[i]);
 852       }
 853     }
 854
 855     for ( ActorContainer::iterator iter = focusableActors.begin(), end = focusableActors.end(); iter != end; ++iter )
 856     {
 857       if ( currentFocusedActor == *iter )
 858       {
 859         switch ( direction )
 860         {
 861           case Toolkit::Control::Left:
 862           {
 863             if ( iter == focusableActors.begin() )
 864             {
 865               nextFocusableActor = *( focusableActors.end() - 1 );
 866             }
 867             else
 868             {
 869               nextFocusableActor = *( iter - 1 );
 870             }
 871             break;
 872           }
 873           case Toolkit::Control::Right:
 874           {
 875             if ( iter == focusableActors.end() - 1 )
 876             {
 877               nextFocusableActor = *( focusableActors.begin() );
 878             }
 879             else
 880             {
 881               nextFocusableActor = *( iter + 1 );
 882             }
 883             break;
 884           }
 885
 886           case Toolkit::Control::Up:
 887           {
 888             if ( *iter == mContent )
 889             {
 890               nextFocusableActor = *( focusableActors.end() - 1 );
 891             }
 892             else
 893             {
 894               if ( mContent && mContent.IsKeyboardFocusable() )
 895               {
 896                 nextFocusableActor = mContent;
 897               }
 898               else
 899               {
 900                 if ( iter == focusableActors.begin() )
 901                 {
 902                   nextFocusableActor = *( focusableActors.end() - 1 );
 903                 }
 904                 else
 905                 {
 906                   nextFocusableActor = *( iter - 1 );
 907                 }
 908               }
 909             }
 910             break;
 911           }
 912
 913           case Toolkit::Control::Down:
 914           {
 915             if ( mContent && mContent.IsKeyboardFocusable() )
 916             {
 917               nextFocusableActor = mContent;
 918             }
 919             else
 920             {
 921               if ( iter == focusableActors.end() - 1 )
 922               {
 923                 nextFocusableActor = *( focusableActors.begin() );
 924               }
 925               else
 926               {
 927                 nextFocusableActor = *( iter + 1 );
 928               }
 929             }
 930
 931             if ( *iter == mContent && !mButtons.empty() )
 932             {
 933               nextFocusableActor = mButtons[0];
 934             }
 935             break;
 936           }
 937         }
 938
 939         if(!nextFocusableActor)
 940         {
 941           DALI_LOG_WARNING("Can not decide next focusable actor\n");
 942         }
 943
 944         break;
 945       }
 946     }
 947   }
 948
 949   return nextFocusableActor;
 950 }
 951
 952 } // namespace Internal
 953
 954 } // namespace Toolkit
 955
 956 } // namespace Dali