dali-toolkit/devel-api/layouting/layout-group-impl.cpp

   1 /*
   2  * Copyright (c) 2018 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 // CLASS HEADER
  18 #include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/public-api/object/type-registry-helper.h>
  22 #include <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/devel-api/object/handle-devel.h>
  24 #include <dali/integration-api/debug.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/layouting/layout-group-data-impl.h>
  28 #include <dali-toolkit/public-api/controls/control-impl.h>
  29 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  30 #include <dali-toolkit/internal/layouting/size-negotiation-mapper.h>
  31
  32 namespace
  33 {
  34 #if defined(DEBUG_ENABLED)
  35 Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_LAYOUT" );
  36 #endif
  37 }
  38
  39 namespace Dali
  40 {
  41 namespace Toolkit
  42 {
  43 namespace Internal
  44 {
  45
  46 LayoutGroup::LayoutGroup()
  47 : mImpl( new LayoutGroup::Impl() ),
  48   mSlotDelegate(this)
  49 {
  50 }
  51
  52 LayoutGroupPtr LayoutGroup::New( Handle& owner )
  53 {
  54   LayoutGroupPtr layoutPtr = new LayoutGroup();
  55   return layoutPtr;
  56 }
  57
  58 LayoutGroup::~LayoutGroup()
  59 {
  60   // An object with a unique_ptr to an opaque structure must define it's destructor in the translation unit
  61   // where the opaque structure is defined. It cannot use the default method in the header file.
  62 }
  63
  64 Toolkit::LayoutGroup::LayoutId LayoutGroup::Add( LayoutItem& child )
  65 {
  66   LayoutParent* oldParent = child.GetParent();
  67   if( oldParent )
  68   {
  69     LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( oldParent ) );
  70     if( parentGroup )
  71     {
  72       parentGroup->Remove( child );
  73     }
  74   }
  75
  76   Impl::ChildLayout childLayout;
  77   childLayout.layoutId = mImpl->mNextLayoutId++;
  78   childLayout.child = &child;
  79   mImpl->mChildren.emplace_back( childLayout );
  80
  81   child.SetParent( this );
  82
  83   auto owner = child.GetOwner();
  84
  85   // If the owner does not have any LayoutItem child properties, add them
  86   if( ! DevelHandle::DoesCustomPropertyExist( owner, Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ) )
  87   {
  88     // Set default properties for LayoutGroup and LayoutItem.
  89     // Deriving classes can override OnChildAdd() to add their own default properties
  90     GenerateDefaultChildPropertyValues( owner );
  91   }
  92
  93   // Inform deriving classes that this child has been added
  94   OnChildAdd( *childLayout.child.Get() );
  95
  96   // Now listen to future changes to the child properties.
  97   DevelHandle::PropertySetSignal(owner).Connect( this, &LayoutGroup::OnSetChildProperties );
  98
  99   RequestLayout();
 100
 101   return childLayout.layoutId;
 102 }
 103
 104 void LayoutGroup::Remove( Toolkit::LayoutGroup::LayoutId childId )
 105 {
 106   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
 107   {
 108     if( iter->layoutId == childId )
 109     {
 110       RemoveChild( *iter->child.Get() );
 111       mImpl->mChildren.erase(iter);
 112       break;
 113     }
 114   }
 115   RequestLayout();
 116 }
 117
 118 void LayoutGroup::Remove( LayoutItem& child )
 119 {
 120   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
 121   {
 122     if( iter->child.Get() == &child )
 123     {
 124       RemoveChild( *iter->child.Get() );
 125       mImpl->mChildren.erase(iter);
 126       break;
 127     }
 128   }
 129   RequestLayout();
 130 }
 131
 132 Toolkit::LayoutGroup::LayoutId LayoutGroup::Insert( LayoutItem& target, LayoutItem& child )
 133 {
 134   LayoutParent* oldParent = child.GetParent();
 135   if( oldParent )
 136   {
 137     LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( oldParent ) );
 138     if( parentGroup )
 139     {
 140       parentGroup->Remove( child );
 141     }
 142   }
 143
 144   // Find target position
 145   std::vector< Impl::ChildLayout >::iterator position;
 146   for( auto iter = mImpl->mChildren.begin(); iter != mImpl->mChildren.end(); ++iter )
 147   {
 148     if( iter->child.Get() == &target )
 149     {
 150       position = iter;
 151       break;
 152     }
 153   }
 154
 155   Impl::ChildLayout childLayout;
 156   childLayout.layoutId = mImpl->mNextLayoutId++;
 157   childLayout.child = &child;
 158   mImpl->mChildren.insert( position, childLayout );
 159
 160   child.SetParent( this );
 161
 162   auto owner = child.GetOwner();
 163
 164   // Inform deriving classes that this child has been added
 165   OnChildAdd( *childLayout.child.Get() );
 166
 167   // Now listen to future changes to the child properties.
 168   DevelHandle::PropertySetSignal(owner).Connect( this, &LayoutGroup::OnSetChildProperties );
 169
 170   RequestLayout();
 171
 172   return childLayout.layoutId;
 173 }
 174
 175 Toolkit::LayoutGroup::LayoutId LayoutGroup::Move( LayoutItem& target, LayoutItem& child )
 176 {
 177   // Remove child from the previous position
 178   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
 179   {
 180     if( iter->child.Get() == &child )
 181     {
 182       mImpl->mChildren.erase( iter );
 183       break;
 184     }
 185   }
 186
 187   // Find target position
 188   std::vector< Impl::ChildLayout >::iterator position;
 189   for( auto iter = mImpl->mChildren.begin(); iter != mImpl->mChildren.end(); ++iter )
 190   {
 191     if( iter->child.Get() == &target )
 192     {
 193       position = iter;
 194       break;
 195     }
 196   }
 197
 198   Impl::ChildLayout childLayout;
 199   childLayout.layoutId = mImpl->mNextLayoutId++;
 200   childLayout.child = &child;
 201   mImpl->mChildren.insert( position, childLayout );
 202
 203   RequestLayout();
 204
 205   return childLayout.layoutId;
 206 }
 207
 208 Toolkit::LayoutGroup::LayoutId LayoutGroup::MoveBack( LayoutItem& child )
 209 {
 210   // Remove child from the previous position
 211   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
 212   {
 213     if( iter->child.Get() == &child )
 214     {
 215       mImpl->mChildren.erase( iter );
 216       break;
 217     }
 218   }
 219
 220   Impl::ChildLayout childLayout;
 221   childLayout.layoutId = mImpl->mNextLayoutId++;
 222   childLayout.child = &child;
 223   mImpl->mChildren.emplace_back( childLayout );
 224
 225   RequestLayout();
 226
 227   return childLayout.layoutId;
 228 }
 229
 230 void LayoutGroup::RemoveAll()
 231 {
 232   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; )
 233   {
 234     RemoveChild( *iter->child.Get() );
 235     iter = mImpl->mChildren.erase(iter);
 236   }
 237 }
 238
 239 unsigned int LayoutGroup::GetChildCount() const
 240 {
 241   return mImpl->mChildren.size();
 242 }
 243
 244 LayoutItemPtr LayoutGroup::GetChildAt( unsigned int index ) const
 245 {
 246   DALI_ASSERT_ALWAYS( index < mImpl->mChildren.size() );
 247   return mImpl->mChildren[ index ].child;
 248 }
 249
 250 LayoutItemPtr LayoutGroup::GetChild( Toolkit::LayoutGroup::LayoutId childId ) const
 251 {
 252   for( auto&& childLayout : mImpl->mChildren )
 253   {
 254     if( childLayout.layoutId == childId )
 255     {
 256       return childLayout.child;
 257     }
 258   }
 259   return NULL;
 260 }
 261
 262 Toolkit::LayoutGroup::LayoutId LayoutGroup::GetChildId( LayoutItem& child ) const
 263 {
 264   for( auto&& childLayout : mImpl->mChildren )
 265   {
 266     if( childLayout.child.Get() == &child )
 267     {
 268       return childLayout.layoutId;
 269     }
 270   }
 271   return Toolkit::LayoutGroup::UNKNOWN_ID;
 272 }
 273
 274 void LayoutGroup::OnChildAdd( LayoutItem& child )
 275 {
 276 }
 277
 278 void LayoutGroup::OnChildRemove( LayoutItem& child )
 279 {
 280 }
 281
 282 void LayoutGroup::DoInitialize()
 283 {
 284 }
 285
 286 void LayoutGroup::DoRegisterChildProperties( const std::string& containerType )
 287 {
 288 }
 289
 290 void LayoutGroup::OnSetChildProperties( Handle& handle, Property::Index index, Property::Value value )
 291 {
 292   DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnSetChildProperties property(" << handle.GetPropertyName(index) << ")\n" );
 293
 294   if ( ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) &&
 295          ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX ) )
 296        ||
 297        ( index == Toolkit::Control::Property::MARGIN || index == Toolkit::Control::Property::PADDING ) )
 298   {
 299     // If any child properties are set, must perform relayout
 300     for( auto&& child : mImpl->mChildren )
 301     {
 302       if( child.child->GetOwner() == handle )
 303       {
 304         child.child->RequestLayout();
 305         break;
 306       }
 307     }
 308   }
 309 }
 310
 311 void LayoutGroup::GenerateDefaultChildPropertyValues( Handle child )
 312 {
 313   child.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION,
 314                      Toolkit::ChildLayoutData::WRAP_CONTENT );
 315   child.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION,
 316                      Toolkit::ChildLayoutData::WRAP_CONTENT );
 317 }
 318
 319 void LayoutGroup::MeasureChildren( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec)
 320 {
 321   for( auto&& child : mImpl->mChildren )
 322   {
 323     //if( (child.mViewFlags & Impl::VISIBILITY_MASK) != Impl::GONE ) // Use owner visibility/enabled/ready
 324     {
 325       MeasureChild( child.child, widthMeasureSpec, heightMeasureSpec );
 326     }
 327   }
 328 }
 329
 330 void LayoutGroup::MeasureChild( LayoutItemPtr child,
 331                                 MeasureSpec parentWidthMeasureSpec,
 332                                 MeasureSpec parentHeightMeasureSpec )
 333 {
 334   DALI_LOG_TRACE_METHOD( gLogFilter );
 335
 336   auto childOwner = child->GetOwner();
 337
 338   auto control = Toolkit::Control::DownCast( childOwner );
 339
 340 #if defined( DEBUG_ENABLED )
 341   if ( control )
 342   {
 343     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild(%s) natural size(%f, %f)\n",
 344                    control.GetName().c_str(), control.GetNaturalSize().width, control.GetNaturalSize().height );
 345   }
 346 #endif
 347
 348
 349   // Get last stored width and height specifications for the child
 350   auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
 351   auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
 352   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild desiredWidth(%d) desiredHeight(%d)\n", desiredWidth, desiredHeight );
 353
 354   auto padding = GetPadding(); // Padding of this layout's owner, not of the child being measured.
 355
 356   const MeasureSpec childWidthMeasureSpec = GetChildMeasureSpec( parentWidthMeasureSpec,
 357                                                                  padding.start + padding.end,
 358                                                                  desiredWidth);
 359   const MeasureSpec childHeightMeasureSpec = GetChildMeasureSpec( parentHeightMeasureSpec,
 360                                                                   padding.top + padding.bottom,
 361                                                                   desiredHeight);
 362
 363   child->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
 364 }
 365
 366 void LayoutGroup::MeasureChildWithMargins( LayoutItemPtr child,
 367                                            MeasureSpec parentWidthMeasureSpec, LayoutLength widthUsed,
 368                                            MeasureSpec parentHeightMeasureSpec, LayoutLength heightUsed)
 369 {
 370   auto childOwner = child->GetOwner();
 371   auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
 372   auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
 373
 374   auto padding = GetPadding(); // Padding of this layout's owner, not of the child being measured.
 375
 376   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins desiredWidth(%d)\n",  desiredWidth );
 377
 378   MeasureSpec childWidthMeasureSpec = GetChildMeasureSpec( parentWidthMeasureSpec,
 379                                                            LayoutLength( padding.start + padding.end ) +
 380                                                            widthUsed, desiredWidth );
 381
 382   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins desiredHeight(%d)\n",  desiredHeight );
 383
 384   MeasureSpec childHeightMeasureSpec = GetChildMeasureSpec( parentHeightMeasureSpec,
 385                                                             LayoutLength( padding.top + padding.bottom )+
 386                                                             heightUsed, desiredHeight );
 387
 388   child->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
 389 }
 390
 391
 392 MeasureSpec LayoutGroup::GetChildMeasureSpec(
 393   MeasureSpec  measureSpec,
 394   LayoutLength padding,
 395   LayoutLength childDimension )
 396 {
 397   auto specMode = measureSpec.GetMode();
 398   LayoutLength specSize = measureSpec.GetSize();
 399
 400   LayoutLength size = std::max( LayoutLength(0), specSize - padding ); // reduce available size by the owners padding
 401
 402   LayoutLength resultSize = 0;
 403   MeasureSpec::Mode resultMode = MeasureSpec::Mode::UNSPECIFIED;
 404
 405   switch( specMode )
 406   {
 407     // Parent has imposed an exact size on us
 408     case MeasureSpec::Mode::EXACTLY:
 409     {
 410       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec MeasureSpec::Mode::EXACTLY\n");
 411       if (childDimension == Toolkit::ChildLayoutData::MATCH_PARENT)
 412       {
 413         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec childDimension MATCH_PARENT\n");
 414
 415         // Child wants to be our size. So be it.
 416         resultSize = size;
 417         resultMode = MeasureSpec::Mode::EXACTLY;
 418       }
 419       else if (childDimension == Toolkit::ChildLayoutData::WRAP_CONTENT)
 420       {
 421         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec childDimension WRAP_CONTENT\n");
 422
 423         // Child wants to determine its own size. It can't be
 424         // bigger than us.
 425         resultSize = size;
 426         resultMode = MeasureSpec::Mode::AT_MOST;
 427       }
 428       else
 429       {
 430         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec childDimension UNSPECIFIED\n");
 431         resultSize = childDimension;
 432         resultMode = MeasureSpec::Mode::EXACTLY;
 433       }
 434
 435       break;
 436     }
 437
 438       // Parent has imposed a maximum size on us
 439     case MeasureSpec::Mode::AT_MOST:
 440     {
 441       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec MeasureSpec::Mode::AT_MOST\n");
 442       if (childDimension == Toolkit::ChildLayoutData::MATCH_PARENT)
 443       {
 444         // Child wants to be our size, but our size is not fixed.
 445         // Constrain child to not be bigger than us.
 446         resultSize = size;
 447         resultMode = MeasureSpec::Mode::AT_MOST;
 448       }
 449       else if (childDimension == Toolkit::ChildLayoutData::WRAP_CONTENT)
 450       {
 451         // Child wants to determine its own size. It can't be
 452         // bigger than us.
 453         resultSize = size;
 454         resultMode = MeasureSpec::Mode::AT_MOST;
 455       }
 456       else
 457       {
 458         // Child wants a specific size... so be it
 459         resultSize = childDimension + padding;
 460         resultMode = MeasureSpec::Mode::EXACTLY;
 461       }
 462
 463       break;
 464     }
 465
 466       // Parent asked to see how big we want to be
 467     case MeasureSpec::Mode::UNSPECIFIED:
 468     {
 469       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec MeasureSpec::Mode::UNSPECIFIED\n");
 470
 471       if (childDimension == Toolkit::ChildLayoutData::MATCH_PARENT)
 472       {
 473         // Child wants to be our size... find out how big it should be
 474         resultSize = LayoutItem::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
 475         resultMode = MeasureSpec::Mode::UNSPECIFIED;
 476       }
 477       else if (childDimension == Toolkit::ChildLayoutData::WRAP_CONTENT)
 478       {
 479         // Child wants to determine its own size.... find out how big
 480         // it should be
 481         resultSize = LayoutItem::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
 482         resultMode = MeasureSpec::Mode::UNSPECIFIED;
 483       }
 484       else
 485       {
 486         // Child wants a specific size... let him have it
 487         resultSize = childDimension + padding;
 488         resultMode = MeasureSpec::Mode::EXACTLY;
 489       }
 490       break;
 491     }
 492   }
 493
 494   DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec resultSize(" << resultSize << ")\n" );
 495
 496   //noinspection ResourceType
 497   return MeasureSpec( resultSize, resultMode );
 498 }
 499
 500
 501 void LayoutGroup::OnInitialize()
 502 {
 503   auto control = Toolkit::Control::DownCast( GetOwner() );
 504
 505   if( control )
 506   {
 507     // Take ownership of existing children
 508     for( unsigned int childIndex = 0 ; childIndex < control.GetChildCount(); ++childIndex )
 509     {
 510       ChildAddedToOwnerImpl( control.GetChildAt( childIndex ) );
 511     }
 512
 513     DevelActor::ChildAddedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildAddedToOwner );
 514     DevelActor::ChildRemovedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildRemovedFromOwner );
 515     DevelActor::ChildOrderChangedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildOrderChanged );
 516     DevelHandle::PropertySetSignal( control ).Connect( mSlotDelegate, &LayoutGroup::OnOwnerPropertySet );
 517
 518     if( control.GetParent() )
 519     {
 520       auto parent = Toolkit::Control::DownCast( control.GetParent() );
 521       if( parent )
 522       {
 523         auto parentLayout = Toolkit::LayoutGroup::DownCast( DevelControl::GetLayout( parent ) );
 524         if( parentLayout )
 525         {
 526           Internal::LayoutGroup& parentLayoutImpl = GetImplementation( parentLayout );
 527
 528           unsigned int count = parent.GetChildCount();
 529           unsigned int index = static_cast< unsigned int >( control.GetProperty< int >( DevelActor::Property::SIBLING_ORDER ) );
 530
 531           // Find insertion position
 532           while( ++index < count )
 533           {
 534             auto sibling = Toolkit::Control::DownCast( parent.GetChildAt( index ) );
 535             if( sibling )
 536             {
 537               auto siblingLayout = DevelControl::GetLayout( sibling );
 538               if( siblingLayout )
 539               {
 540                 Internal::LayoutItem& siblingLayoutImpl = GetImplementation( siblingLayout );
 541                 parentLayoutImpl.Insert( siblingLayoutImpl, *this );
 542                 break;
 543               }
 544             }
 545           }
 546
 547           if( index >= count )
 548           {
 549             parentLayoutImpl.Add( *this );
 550           }
 551         }
 552       }
 553     }
 554
 555     RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_OWNER_SET );
 556   }
 557 }
 558
 559 void LayoutGroup::OnRegisterChildProperties( const std::string& containerType )
 560 {
 561   DoRegisterChildProperties( containerType );
 562 }
 563
 564 void LayoutGroup::OnUnparent()
 565 {
 566   // Remove children
 567   RemoveAll();
 568
 569   auto control = Toolkit::Control::DownCast( GetOwner() );
 570   if( control )
 571   {
 572     DevelActor::ChildAddedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildAddedToOwner );
 573     DevelActor::ChildRemovedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildRemovedFromOwner );
 574     DevelActor::ChildOrderChangedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildOrderChanged );
 575     DevelHandle::PropertySetSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::OnOwnerPropertySet );
 576   }
 577 }
 578
 579 void LayoutGroup::RemoveChild( LayoutItem& item )
 580 {
 581   item.SetParent( nullptr );
 582   OnChildRemove( item );
 583 }
 584
 585 void LayoutGroup::ChildAddedToOwner( Actor child )
 586 {
 587   ChildAddedToOwnerImpl( child );
 588   RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_CHILD_ADD, child, Actor() );
 589 }
 590
 591 void LayoutGroup::ChildAddedToOwnerImpl( Actor child )
 592 {
 593   LayoutItemPtr childLayout;
 594   Toolkit::Control control = Toolkit::Control::DownCast( child );
 595
 596 #if defined(DEBUG_ENABLED)
 597   auto parent = Toolkit::Control::DownCast( GetOwner() );
 598   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control(%s) owner control(%s)\n",
 599                                               control?control.GetName().c_str():"Invalid",
 600                                               parent?parent.GetName().c_str():"Invalid" );
 601 #endif
 602
 603   if( control ) // Can only support adding Controls, not Actors to layout
 604   {
 605     Internal::Control& childControlImpl = GetImplementation( control );
 606     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 607     childLayout = childControlDataImpl.GetLayout();
 608
 609     if( ! childLayout )
 610     {
 611       // If the child doesn't already have a layout, then create a LayoutItem or LayoutGroup for it.
 612       // If control behaviour flag set to Layout then set a LayoutGroup.
 613       if( DevelControl::IsLayoutingRequired( control ) )
 614       {
 615         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutGroup for control:%s\n",
 616                                                     control?control.GetName().c_str():"Invalid" );
 617         childLayout = LayoutGroup::New( control );
 618       }
 619       else
 620       {
 621         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutItem for control:%s\n",
 622                                                     control?control.GetName().c_str():"Invalid" );
 623         childLayout = LayoutItem::New( control );
 624         childLayout->SetAnimateLayout( IsLayoutAnimated() ); // forces animation inheritance.
 625       }
 626
 627       DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control:" <<  control.GetName() <<
 628                        " desiredWidth: " <<  control.GetNaturalSize().width <<
 629                        " desiredHeight:"  << control.GetNaturalSize().height );
 630
 631       childControlDataImpl.SetLayout( *childLayout.Get() );
 632
 633       Vector3 size = child.GetTargetSize();
 634       // If the size of the control is set explicitly make sure that the control size
 635       // stays the same after the layout except it is over written with match parent specs.
 636       if ( size.x != 0 )
 637       {
 638         childLayout->SetMinimumWidth( size.x );
 639       }
 640
 641       if ( size.y != 0 )
 642       {
 643         childLayout->SetMinimumHeight( size.y );
 644       }
 645       // Default layout data will be generated by Add().
 646     }
 647     else
 648     {
 649       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child(%s) already has a Layout\n", control.GetName().c_str() );
 650       LayoutGroupPtr layoutGroup( dynamic_cast< LayoutGroup* >( childLayout.Get() ) );
 651       if( !layoutGroup )
 652       {
 653         // Set only in case of leaf children
 654         childLayout->SetAnimateLayout( IsLayoutAnimated() );
 655       }
 656     }
 657
 658     Add( *childLayout.Get() );
 659   }
 660 }
 661
 662 void LayoutGroup::ChildRemovedFromOwner( Actor child )
 663 {
 664   Toolkit::Control control = Toolkit::Control::DownCast( child );
 665   if( control )
 666   {
 667     Internal::Control& childControlImpl = GetImplementation( control );
 668     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 669     auto childLayout = childControlDataImpl.GetLayout();
 670     if( childLayout )
 671     {
 672       Remove( *childLayout.Get() );
 673       RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_CHILD_REMOVE, child, Actor() );
 674     }
 675   }
 676 }
 677
 678 void LayoutGroup::ChildOrderChanged( Actor child )
 679 {
 680   Toolkit::Control childControl = Toolkit::Control::DownCast( child );
 681   if( childControl )
 682   {
 683     Internal::Control& childControlImpl = GetImplementation( childControl );
 684     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 685
 686     auto childLayout = childControlDataImpl.GetLayout();
 687     if( childLayout )
 688     {
 689       Toolkit::Control control = Toolkit::Control::DownCast( GetOwner() );
 690       unsigned int count = control.GetChildCount();
 691       unsigned int index = static_cast< unsigned int >( childControl.GetProperty< int >( DevelActor::Property::SIBLING_ORDER ) );
 692
 693       // Find insertion position
 694       while( ++index < count )
 695       {
 696         auto sibling = Toolkit::Control::DownCast( control.GetChildAt( index ) );
 697         if( sibling )
 698         {
 699           auto siblingLayout = DevelControl::GetLayout( sibling );
 700           if( siblingLayout )
 701           {
 702             Internal::LayoutItem& siblingLayoutImpl = GetImplementation( siblingLayout );
 703             Move( siblingLayoutImpl, *childLayout );
 704             return;
 705           }
 706         }
 707       }
 708
 709       MoveBack( *childLayout );
 710     }
 711   }
 712 }
 713
 714 void LayoutGroup::OnOwnerPropertySet( Handle& handle, Property::Index index, Property::Value value )
 715 {
 716   DALI_LOG_INFO( gLogFilter, Debug::Concise, "LayoutGroup::OnOwnerPropertySet\n");
 717   auto actor = Actor::DownCast( handle );
 718   if( actor &&
 719       (
 720         index == Actor::Property::LAYOUT_DIRECTION  ||
 721         index == Toolkit::Control::Property::PADDING  ||
 722         index == Toolkit::Control::Property::MARGIN
 723       )
 724     )
 725   {
 726     RequestLayout();
 727   }
 728 }
 729
 730 void LayoutGroup::OnAnimationStateChanged( bool animateLayout )
 731 {
 732   // Change children's animation state
 733   for( auto&& child : mImpl->mChildren )
 734   {
 735     LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( child.child.Get() ) );
 736     if( ! parentGroup )
 737     {
 738       // Change state only in case of leaf children
 739       child.child->SetAnimateLayout( animateLayout );
 740     }
 741   }
 742 }
 743
 744 void LayoutGroup::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
 745 {
 746   auto childCount = GetChildCount();
 747
 748   DALI_LOG_STREAM( gLogFilter, Debug::Verbose,
 749                   "LayoutGroup::OnMeasure Actor Id:" <<  Actor::DownCast(GetOwner()).GetId() <<
 750                   " Owner:" <<  Actor::DownCast(GetOwner()).GetName() <<
 751                   " Child Count:" << childCount <<
 752                   " MeasureSpecs( width:"<<widthMeasureSpec<<", height:"<<heightMeasureSpec );
 753
 754   auto widthMode = widthMeasureSpec.GetMode();
 755   auto heightMode = heightMeasureSpec.GetMode();
 756   LayoutLength widthSpecSize = widthMeasureSpec.GetSize();
 757   LayoutLength heightSpecSize = heightMeasureSpec.GetSize();
 758
 759   bool exactWidth ( false );
 760   bool exactHeight ( false );
 761
 762   // Layouting behaviour
 763   // EXACT, width and height as provided.
 764   // MATCH_PARENT, width and height that of parent
 765   // WRAP_CONTENT, take width of widest child and height size of longest child (within given limit)
 766   // UNSPECIFIED, take width of widest child and height size of longest child.
 767
 768   LayoutLength layoutWidth( 0 );
 769   LayoutLength layoutHeight( 0 );
 770
 771   // If LayoutGroup has children then measure children to get max dimensions
 772   if ( childCount > 0 )
 773   {
 774     for( unsigned int i=0; i<childCount; ++i )
 775     {
 776       auto childLayout = GetChildAt( i );
 777       if( childLayout )
 778       {
 779         auto childControl = Toolkit::Control::DownCast(childLayout->GetOwner());
 780
 781         // If child control has children check if a ResizePolicy is set on it.  A LayoutItem could be a legacy container.
 782         // A legacy container would need it's ResizePolicy to be applied as a MeasureSpec.
 783
 784         // Check below will be true for legacy containers and controls with layout required set.
 785         // Other layouts will have their own OnMeasure (a checked requirement) hence not execute LayoutGroup::OnMeasure.
 786         // Controls which have set layout required will not be legacy controls hence should not have a ResizePolicy set.
 787         if( childControl.GetChildCount() > 0 )
 788         {
 789           // First pass, Static mappings that are not dependant on parent
 790           SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::WIDTH );
 791           SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::HEIGHT );
 792         }
 793
 794         // Second pass, if any mappings were not possible due to parent size dependancies then calculate an exact desired size for child
 795         if( true == childLayout->IsResizePolicyRequired() ) // No need to test child count as this flag would only be set if control had children.
 796         {
 797           // Get last stored width and height specifications for the child
 798           LayoutLength desiredWidth = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
 799           LayoutLength desiredHeight = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
 800
 801           DALI_LOG_INFO( gLogFilter, Debug::General, "LayoutGroup::MeasureChild Initial desired size pre ResizePolicy(%f,%f)\n", desiredWidth.AsInteger(), desiredHeight.AsInteger() );
 802
 803           childLayout->SetResizePolicyRequired( false ); // clear flag incase in case of changes before next Measure
 804           SizeNegotiationMapper::GetSizeofChildForParentDependentResizePolicy( childControl, widthMeasureSpec, heightMeasureSpec, desiredWidth, desiredHeight );
 805
 806           // Parent dependant ResizePolicies become exact sizes so are now set on the child before it's measured.
 807           childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, desiredWidth.AsInteger() );
 808           childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, desiredHeight.AsInteger()  );
 809
 810           DALI_LOG_INFO( gLogFilter, Debug::General, " LayoutGroup::OnMeasure ResizePolicy Required resulting size(%f,%f)\n",  desiredWidth.AsInteger(), desiredHeight.AsInteger() );
 811         }
 812
 813         // Get size of child
 814         MeasureChild( childLayout, widthMeasureSpec, heightMeasureSpec );
 815         LayoutLength childWidth = childLayout->GetMeasuredWidth();
 816         LayoutLength childHeight = childLayout->GetMeasuredHeight();
 817
 818         Extents childMargin = childLayout->GetMargin();
 819         DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure child " << childControl.GetName().c_str() << " width[" << childWidth << "] height[" << childHeight << "]\n" );
 820
 821         layoutWidth = std::max( layoutWidth, childWidth + childMargin.start + childMargin.end );
 822         layoutHeight = std::max( layoutHeight, childHeight + childMargin.top + childMargin.bottom );
 823         DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure calculated child width[" << layoutWidth << "] height[" << layoutHeight << "]\n" );
 824       }
 825       else
 826       {
 827         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Not a layout\n" );
 828       }
 829     }
 830
 831     Extents padding = GetPadding();
 832     layoutWidth += padding.start + padding.end;
 833     layoutHeight += padding.top + padding.bottom;
 834   }
 835   else
 836   {
 837     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Getting default size as a leaf\n" );
 838     // LayoutGroup does not contain any children so must be a leaf
 839     layoutWidth = GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec );
 840     layoutHeight = GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec );
 841   }
 842
 843   // Can't exceed specified width
 844   if( widthMode == MeasureSpec::Mode::EXACTLY )
 845   {
 846     exactWidth = true;
 847   }
 848   else if ( widthMode == MeasureSpec::Mode::AT_MOST )
 849   {
 850     layoutWidth = std::min( layoutWidth, widthSpecSize );
 851   }
 852
 853   // Can't exceed specified height
 854   if( heightMode == MeasureSpec::Mode::EXACTLY )
 855   {
 856     exactHeight = true;
 857   }
 858   else if ( heightMode == MeasureSpec::Mode::AT_MOST )
 859   {
 860     layoutHeight = std::min( layoutHeight, heightSpecSize );
 861   }
 862
 863   layoutWidth = std::max( layoutWidth, GetSuggestedMinimumWidth() );
 864   layoutHeight = std::max( layoutHeight, GetSuggestedMinimumHeight() );
 865
 866   if( exactWidth )
 867   {
 868     layoutWidth = widthSpecSize;
 869   }
 870
 871   if( exactHeight )
 872   {
 873     layoutHeight = heightSpecSize;
 874   }
 875
 876   DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnMeasure Measured size(" << layoutWidth << "," << layoutHeight << ") for : " << Actor::DownCast(GetOwner()).GetName() << " \n" );
 877   SetMeasuredDimensions( MeasuredSize( layoutWidth ), MeasuredSize( layoutHeight ) );
 878 }
 879
 880 void LayoutGroup::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
 881 {
 882   auto count = GetChildCount();
 883
 884   DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup OnLayout owner:" << ( ( Toolkit::Control::DownCast(GetOwner())) ? Toolkit::Control::DownCast(GetOwner()).GetName() : "invalid" )  << " childCount:" << count );
 885
 886   for( unsigned int childIndex = 0; childIndex < count; childIndex++)
 887   {
 888     LayoutItemPtr childLayout = GetChildAt( childIndex );
 889     if( childLayout != nullptr )
 890     {
 891
 892       auto childOwner = childLayout->GetOwner();
 893       LayoutLength childWidth = childLayout->GetMeasuredWidth();
 894       LayoutLength childHeight = childLayout->GetMeasuredHeight();
 895       Extents childMargin = childLayout->GetMargin();
 896       auto control = Toolkit::Control::DownCast( childOwner );
 897       Extents padding = GetPadding();
 898
 899       auto childPosition = control.GetProperty< Vector3 >( Actor::Property::POSITION );
 900       auto anchorPoint = control.GetProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
 901
 902       DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnLayout child[" << control.GetName() <<
 903                        "] position(" << childPosition << ") child width[" << childWidth << "] height[" << childHeight << "]\n" );
 904
 905       // Margin and Padding only supported when child anchor point is TOP_LEFT.
 906       int paddingAndMarginOffsetX = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.top + childMargin.top ) : 0;
 907       int paddingAndMarginOffsetY = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.start + childMargin.start ) : 0;
 908       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnLayout paddingMargin offset(%d,%d)\n", paddingAndMarginOffsetX, paddingAndMarginOffsetY );
 909
 910       LayoutLength childLeft = childPosition.x + paddingAndMarginOffsetX;
 911       LayoutLength childTop = childPosition.y + paddingAndMarginOffsetY;
 912
 913       childLayout->Layout( childLeft, childTop, childLeft + childWidth, childTop + childHeight );
 914     }
 915   }
 916 }
 917
 918
 919 } // namespace Internal
 920 } // namespace Toolkit
 921 } // namespace Dali