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       ChildAddedToOwner( 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 }
 556
 557 void LayoutGroup::OnRegisterChildProperties( const std::string& containerType )
 558 {
 559   DoRegisterChildProperties( containerType );
 560 }
 561
 562 void LayoutGroup::OnUnparent()
 563 {
 564   // Remove children
 565   RemoveAll();
 566
 567   auto control = Toolkit::Control::DownCast( GetOwner() );
 568   if( control )
 569   {
 570     DevelActor::ChildAddedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildAddedToOwner );
 571     DevelActor::ChildRemovedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildRemovedFromOwner );
 572     DevelActor::ChildOrderChangedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildOrderChanged );
 573     DevelHandle::PropertySetSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::OnOwnerPropertySet );
 574   }
 575 }
 576
 577 void LayoutGroup::RemoveChild( LayoutItem& item )
 578 {
 579   item.SetParent( nullptr );
 580   OnChildRemove( item );
 581 }
 582
 583 void LayoutGroup::ChildAddedToOwner( Actor child )
 584 {
 585   LayoutItemPtr childLayout;
 586   Toolkit::Control control = Toolkit::Control::DownCast( child );
 587
 588 #if defined(DEBUG_ENABLED)
 589   auto parent = Toolkit::Control::DownCast( GetOwner() );
 590   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control(%s) owner control(%s)\n",
 591                                               control?control.GetName().c_str():"Invalid",
 592                                               parent?parent.GetName().c_str():"Invalid" );
 593 #endif
 594
 595   if( control ) // Can only support adding Controls, not Actors to layout
 596   {
 597     Internal::Control& childControlImpl = GetImplementation( control );
 598     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 599     childLayout = childControlDataImpl.GetLayout();
 600
 601     if( ! childLayout )
 602     {
 603       // If the child doesn't already have a layout, then create a LayoutItem or LayoutGroup for it.
 604       // If control behaviour flag set to Layout then set a LayoutGroup.
 605       if( DevelControl::IsLayoutingRequired( control ) )
 606       {
 607         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutGroup for control:%s\n",
 608                                                     control?control.GetName().c_str():"Invalid" );
 609         childLayout = LayoutGroup::New( control );
 610       }
 611       else
 612       {
 613         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutItem for control:%s\n",
 614                                                     control?control.GetName().c_str():"Invalid" );
 615         childLayout = LayoutItem::New( control );
 616         childLayout->SetAnimateLayout( IsLayoutAnimated() ); // forces animation inheritance.
 617       }
 618
 619       DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control:" <<  control.GetName() <<
 620                        " desiredWidth: " <<  control.GetNaturalSize().width <<
 621                        " desiredHeight:"  << control.GetNaturalSize().height );
 622
 623       childControlDataImpl.SetLayout( *childLayout.Get() );
 624
 625       Vector3 size = child.GetTargetSize();
 626       // If the size of the control is set explicitly make sure that the control size
 627       // stays the same after the layout except it is over written with match parent specs.
 628       if ( size.x != 0 )
 629       {
 630         childLayout->SetMinimumWidth( size.x );
 631       }
 632
 633       if ( size.y != 0 )
 634       {
 635         childLayout->SetMinimumHeight( size.y );
 636       }
 637       // Default layout data will be generated by Add().
 638     }
 639     else
 640     {
 641       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child(%s) already has a Layout\n", control.GetName().c_str() );
 642       LayoutGroupPtr layoutGroup( dynamic_cast< LayoutGroup* >( childLayout.Get() ) );
 643       if( !layoutGroup )
 644       {
 645         // Set only in case of leaf children
 646         childLayout->SetAnimateLayout( IsLayoutAnimated() );
 647       }
 648     }
 649
 650     Add( *childLayout.Get() );
 651   }
 652 }
 653
 654 void LayoutGroup::ChildRemovedFromOwner( Actor child )
 655 {
 656   Toolkit::Control control = Toolkit::Control::DownCast( child );
 657   if( control )
 658   {
 659     Internal::Control& childControlImpl = GetImplementation( control );
 660     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 661     auto childLayout = childControlDataImpl.GetLayout();
 662     if( childLayout )
 663     {
 664       Remove( *childLayout.Get() );
 665     }
 666   }
 667 }
 668
 669 void LayoutGroup::ChildOrderChanged( Actor child )
 670 {
 671   Toolkit::Control childControl = Toolkit::Control::DownCast( child );
 672   if( childControl )
 673   {
 674     Internal::Control& childControlImpl = GetImplementation( childControl );
 675     Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
 676
 677     auto childLayout = childControlDataImpl.GetLayout();
 678     if( childLayout )
 679     {
 680       Toolkit::Control control = Toolkit::Control::DownCast( GetOwner() );
 681       unsigned int count = control.GetChildCount();
 682       unsigned int index = static_cast< unsigned int >( childControl.GetProperty< int >( DevelActor::Property::SIBLING_ORDER ) );
 683
 684       // Find insertion position
 685       while( ++index < count )
 686       {
 687         auto sibling = Toolkit::Control::DownCast( control.GetChildAt( index ) );
 688         if( sibling )
 689         {
 690           auto siblingLayout = DevelControl::GetLayout( sibling );
 691           if( siblingLayout )
 692           {
 693             Internal::LayoutItem& siblingLayoutImpl = GetImplementation( siblingLayout );
 694             Move( siblingLayoutImpl, *childLayout );
 695             return;
 696           }
 697         }
 698       }
 699
 700       MoveBack( *childLayout );
 701     }
 702   }
 703 }
 704
 705 void LayoutGroup::OnOwnerPropertySet( Handle& handle, Property::Index index, Property::Value value )
 706 {
 707   DALI_LOG_INFO( gLogFilter, Debug::Concise, "LayoutGroup::OnOwnerPropertySet\n");
 708   auto actor = Actor::DownCast( handle );
 709   if( actor &&
 710       (
 711         index == Actor::Property::LAYOUT_DIRECTION  ||
 712         index == Toolkit::Control::Property::PADDING  ||
 713         index == Toolkit::Control::Property::MARGIN
 714       )
 715     )
 716   {
 717     RequestLayout();
 718   }
 719 }
 720
 721 void LayoutGroup::OnAnimationStateChanged( bool animateLayout )
 722 {
 723   // Change children's animation state
 724   for( auto&& child : mImpl->mChildren )
 725   {
 726     LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( child.child.Get() ) );
 727     if( ! parentGroup )
 728     {
 729       // Change state only in case of leaf children
 730       child.child->SetAnimateLayout( animateLayout );
 731     }
 732   }
 733 }
 734
 735 void LayoutGroup::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
 736 {
 737   auto childCount = GetChildCount();
 738
 739   DALI_LOG_STREAM( gLogFilter, Debug::Verbose,
 740                   "LayoutGroup::OnMeasure Actor Id:" <<  Actor::DownCast(GetOwner()).GetId() <<
 741                   " Owner:" <<  Actor::DownCast(GetOwner()).GetName() <<
 742                   " Child Count:" << childCount <<
 743                   " MeasureSpecs( width:"<<widthMeasureSpec<<", height:"<<heightMeasureSpec );
 744
 745   auto widthMode = widthMeasureSpec.GetMode();
 746   auto heightMode = heightMeasureSpec.GetMode();
 747   LayoutLength widthSpecSize = widthMeasureSpec.GetSize();
 748   LayoutLength heightSpecSize = heightMeasureSpec.GetSize();
 749
 750   bool exactWidth ( false );
 751   bool exactHeight ( false );
 752
 753   // Layouting behaviour
 754   // EXACT, width and height as provided.
 755   // MATCH_PARENT, width and height that of parent
 756   // WRAP_CONTENT, take width of widest child and height size of longest child (within given limit)
 757   // UNSPECIFIED, take width of widest child and height size of longest child.
 758
 759   LayoutLength layoutWidth( 0 );
 760   LayoutLength layoutHeight( 0 );
 761
 762   // If LayoutGroup has children then measure children to get max dimensions
 763   if ( childCount > 0 )
 764   {
 765     for( unsigned int i=0; i<childCount; ++i )
 766     {
 767       auto childLayout = GetChildAt( i );
 768       if( childLayout )
 769       {
 770         auto childControl = Toolkit::Control::DownCast(childLayout->GetOwner());
 771
 772         // If child control has children check if a ResizePolicy is set on it.  A LayoutItem could be a legacy container.
 773         // A legacy container would need it's ResizePolicy to be applied as a MeasureSpec.
 774
 775         // Check below will be true for legacy containers and controls with layout required set.
 776         // Other layouts will have their own OnMeasure (a checked requirement) hence not execute LayoutGroup::OnMeasure.
 777         // Controls which have set layout required will not be legacy controls hence should not have a ResizePolicy set.
 778         if( childControl.GetChildCount() > 0 )
 779         {
 780           // First pass, Static mappings that are not dependant on parent
 781           SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::WIDTH );
 782           SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::HEIGHT );
 783         }
 784
 785         // Second pass, if any mappings were not possible due to parent size dependancies then calculate an exact desired size for child
 786         if( true == childLayout->IsResizePolicyRequired() ) // No need to test child count as this flag would only be set if control had children.
 787         {
 788           // Get last stored width and height specifications for the child
 789           LayoutLength desiredWidth = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
 790           LayoutLength desiredHeight = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
 791
 792           DALI_LOG_INFO( gLogFilter, Debug::General, "LayoutGroup::MeasureChild Initial desired size pre ResizePolicy(%f,%f)\n", desiredWidth.AsInteger(), desiredHeight.AsInteger() );
 793
 794           childLayout->SetResizePolicyRequired( false ); // clear flag incase in case of changes before next Measure
 795           SizeNegotiationMapper::GetSizeofChildForParentDependentResizePolicy( childControl, widthMeasureSpec, heightMeasureSpec, desiredWidth, desiredHeight );
 796
 797           // Parent dependant ResizePolicies become exact sizes so are now set on the child before it's measured.
 798           childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, desiredWidth.AsInteger() );
 799           childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, desiredHeight.AsInteger()  );
 800
 801           DALI_LOG_INFO( gLogFilter, Debug::General, " LayoutGroup::OnMeasure ResizePolicy Required resulting size(%f,%f)\n",  desiredWidth.AsInteger(), desiredHeight.AsInteger() );
 802         }
 803
 804         // Get size of child
 805         MeasureChild( childLayout, widthMeasureSpec, heightMeasureSpec );
 806         LayoutLength childWidth = childLayout->GetMeasuredWidth();
 807         LayoutLength childHeight = childLayout->GetMeasuredHeight();
 808
 809         Extents childMargin = childLayout->GetMargin();
 810         DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure child " << childControl.GetName().c_str() << " width[" << childWidth << "] height[" << childHeight << "]\n" );
 811
 812         layoutWidth = std::max( layoutWidth, childWidth + childMargin.start + childMargin.end );
 813         layoutHeight = std::max( layoutHeight, childHeight + childMargin.top + childMargin.bottom );
 814         DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure calculated child width[" << layoutWidth << "] height[" << layoutHeight << "]\n" );
 815       }
 816       else
 817       {
 818         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Not a layout\n" );
 819       }
 820     }
 821
 822     Extents padding = GetPadding();
 823     layoutWidth += padding.start + padding.end;
 824     layoutHeight += padding.top + padding.bottom;
 825   }
 826   else
 827   {
 828     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Getting default size as a leaf\n" );
 829     // LayoutGroup does not contain any children so must be a leaf
 830     layoutWidth = GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec );
 831     layoutHeight = GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec );
 832   }
 833
 834   // Can't exceed specified width
 835   if( widthMode == MeasureSpec::Mode::EXACTLY )
 836   {
 837     exactWidth = true;
 838   }
 839   else if ( widthMode == MeasureSpec::Mode::AT_MOST )
 840   {
 841     layoutWidth = std::min( layoutWidth, widthSpecSize );
 842   }
 843
 844   // Can't exceed specified height
 845   if( heightMode == MeasureSpec::Mode::EXACTLY )
 846   {
 847     exactHeight = true;
 848   }
 849   else if ( heightMode == MeasureSpec::Mode::AT_MOST )
 850   {
 851     layoutHeight = std::min( layoutHeight, heightSpecSize );
 852   }
 853
 854   layoutWidth = std::max( layoutWidth, GetSuggestedMinimumWidth() );
 855   layoutHeight = std::max( layoutHeight, GetSuggestedMinimumHeight() );
 856
 857   if( exactWidth )
 858   {
 859     layoutWidth = widthSpecSize;
 860   }
 861
 862   if( exactHeight )
 863   {
 864     layoutHeight = heightSpecSize;
 865   }
 866
 867   DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnMeasure Measured size(" << layoutWidth << "," << layoutHeight << ") for : " << Actor::DownCast(GetOwner()).GetName() << " \n" );
 868   SetMeasuredDimensions( MeasuredSize( layoutWidth ), MeasuredSize( layoutHeight ) );
 869 }
 870
 871 void LayoutGroup::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
 872 {
 873   auto count = GetChildCount();
 874
 875   DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup OnLayout owner:" << ( ( Toolkit::Control::DownCast(GetOwner())) ? Toolkit::Control::DownCast(GetOwner()).GetName() : "invalid" )  << " childCount:" << count );
 876
 877   for( unsigned int childIndex = 0; childIndex < count; childIndex++)
 878   {
 879     LayoutItemPtr childLayout = GetChildAt( childIndex );
 880     if( childLayout != nullptr )
 881     {
 882
 883       auto childOwner = childLayout->GetOwner();
 884       LayoutLength childWidth = childLayout->GetMeasuredWidth();
 885       LayoutLength childHeight = childLayout->GetMeasuredHeight();
 886       Extents childMargin = childLayout->GetMargin();
 887       auto control = Toolkit::Control::DownCast( childOwner );
 888       Extents padding = GetPadding();
 889
 890       auto childPosition = control.GetProperty< Vector3 >( Actor::Property::POSITION );
 891       auto anchorPoint = control.GetProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
 892
 893       DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnLayout child[" << control.GetName() <<
 894                        "] position(" << childPosition << ") child width[" << childWidth << "] height[" << childHeight << "]\n" );
 895
 896       // Margin and Padding only supported when child anchor point is TOP_LEFT.
 897       int paddingAndMarginOffsetX = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.top + childMargin.top ) : 0;
 898       int paddingAndMarginOffsetY = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.start + childMargin.start ) : 0;
 899       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnLayout paddingMargin offset(%d,%d)\n", paddingAndMarginOffsetX, paddingAndMarginOffsetY );
 900
 901       LayoutLength childLeft = childPosition.x + paddingAndMarginOffsetX;
 902       LayoutLength childTop = childPosition.y + paddingAndMarginOffsetY;
 903
 904       childLayout->Layout( childLeft, childTop, childLeft + childWidth, childTop + childHeight );
 905     }
 906   }
 907 }
 908
 909
 910 } // namespace Internal
 911 } // namespace Toolkit
 912 } // namespace Dali