X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Fdevel-api%2Flayouting%2Flayout-group-impl.cpp;h=d088a5ac77396e85e645a071c3d55b21fce13670;hb=9921868a204bf0132f7d5ddacae75c47b7550e80;hp=d28ec901fcd44935ed2eba5ad76bc88c468b6574;hpb=5a436526e75ad9bef35e98614a00527fe5586f78;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/dali-toolkit/devel-api/layouting/layout-group-impl.cpp b/dali-toolkit/devel-api/layouting/layout-group-impl.cpp
old mode 100644
new mode 100755
index d28ec90..d088a5a
--- a/dali-toolkit/devel-api/layouting/layout-group-impl.cpp
+++ b/dali-toolkit/devel-api/layouting/layout-group-impl.cpp
@@ -27,6 +27,7 @@
 #include <dali-toolkit/internal/layouting/layout-group-data-impl.h>
 #include <dali-toolkit/public-api/controls/control-impl.h>
 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
+#include <dali-toolkit/internal/layouting/size-negotiation-mapper.h>
 
 namespace
 {
@@ -48,10 +49,17 @@ LayoutGroup::LayoutGroup()
 {
 }
 
+LayoutGroupPtr LayoutGroup::New( Handle& owner )
+{
+  LayoutGroupPtr layoutPtr = new LayoutGroup();
+  return layoutPtr;
+}
+
 LayoutGroup::~LayoutGroup()
 {
   // An object with a unique_ptr to an opaque structure must define it's destructor in the translation unit
   // where the opaque structure is defined. It cannot use the default method in the header file.
+  RemoveAll();
 }
 
 Toolkit::LayoutGroup::LayoutId LayoutGroup::Add( LayoutItem& child )
@@ -100,7 +108,7 @@ void LayoutGroup::Remove( Toolkit::LayoutGroup::LayoutId childId )
   {
     if( iter->layoutId == childId )
     {
-      OnChildRemove( *iter->child.Get() );
+      RemoveChild( *iter->child.Get() );
       mImpl->mChildren.erase(iter);
       break;
     }
@@ -114,7 +122,7 @@ void LayoutGroup::Remove( LayoutItem& child )
   {
     if( iter->child.Get() == &child )
     {
-      OnChildRemove( *iter->child.Get() );
+      RemoveChild( *iter->child.Get() );
       mImpl->mChildren.erase(iter);
       break;
     }
@@ -122,11 +130,109 @@ void LayoutGroup::Remove( LayoutItem& child )
   RequestLayout();
 }
 
+Toolkit::LayoutGroup::LayoutId LayoutGroup::Insert( LayoutItem& target, LayoutItem& child )
+{
+  LayoutParent* oldParent = child.GetParent();
+  if( oldParent )
+  {
+    LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( oldParent ) );
+    if( parentGroup )
+    {
+      parentGroup->Remove( child );
+    }
+  }
+
+  // Find target position
+  std::vector< Impl::ChildLayout >::iterator position;
+  for( auto iter = mImpl->mChildren.begin(); iter != mImpl->mChildren.end(); ++iter )
+  {
+    if( iter->child.Get() == &target )
+    {
+      position = iter;
+      break;
+    }
+  }
+
+  Impl::ChildLayout childLayout;
+  childLayout.layoutId = mImpl->mNextLayoutId++;
+  childLayout.child = &child;
+  mImpl->mChildren.insert( position, childLayout );
+
+  child.SetParent( this );
+
+  auto owner = child.GetOwner();
+
+  // Inform deriving classes that this child has been added
+  OnChildAdd( *childLayout.child.Get() );
+
+  // Now listen to future changes to the child properties.
+  DevelHandle::PropertySetSignal(owner).Connect( this, &LayoutGroup::OnSetChildProperties );
+
+  RequestLayout();
+
+  return childLayout.layoutId;
+}
+
+Toolkit::LayoutGroup::LayoutId LayoutGroup::Move( LayoutItem& target, LayoutItem& child )
+{
+  // Remove child from the previous position
+  for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
+  {
+    if( iter->child.Get() == &child )
+    {
+      mImpl->mChildren.erase( iter );
+      break;
+    }
+  }
+
+  // Find target position
+  std::vector< Impl::ChildLayout >::iterator position;
+  for( auto iter = mImpl->mChildren.begin(); iter != mImpl->mChildren.end(); ++iter )
+  {
+    if( iter->child.Get() == &target )
+    {
+      position = iter;
+      break;
+    }
+  }
+
+  Impl::ChildLayout childLayout;
+  childLayout.layoutId = mImpl->mNextLayoutId++;
+  childLayout.child = &child;
+  mImpl->mChildren.insert( position, childLayout );
+
+  RequestLayout();
+
+  return childLayout.layoutId;
+}
+
+Toolkit::LayoutGroup::LayoutId LayoutGroup::MoveBack( LayoutItem& child )
+{
+  // Remove child from the previous position
+  for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
+  {
+    if( iter->child.Get() == &child )
+    {
+      mImpl->mChildren.erase( iter );
+      break;
+    }
+  }
+
+  Impl::ChildLayout childLayout;
+  childLayout.layoutId = mImpl->mNextLayoutId++;
+  childLayout.child = &child;
+  mImpl->mChildren.emplace_back( childLayout );
+
+  RequestLayout();
+
+  return childLayout.layoutId;
+}
+
 void LayoutGroup::RemoveAll()
 {
   for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; )
   {
-    OnChildRemove( *iter->child.Get() );
+    RemoveChild( *iter->child.Get() );
     iter = mImpl->mChildren.erase(iter);
   }
 }
@@ -184,7 +290,7 @@ void LayoutGroup::DoRegisterChildProperties( const std::string& containerType )
 
 void LayoutGroup::OnSetChildProperties( Handle& handle, Property::Index index, Property::Value value )
 {
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnSetChildProperties property(%s)\n", handle.GetPropertyName(index).c_str());
+  DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnSetChildProperties property(" << handle.GetPropertyName(index) << ")\n" );
 
   if ( ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) &&
          ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX ) )
@@ -235,14 +341,16 @@ void LayoutGroup::MeasureChild( LayoutItemPtr child,
 #if defined( DEBUG_ENABLED )
   if ( control )
   {
-    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild natural size(%f, %f)\n",  control.GetNaturalSize().width, control.GetNaturalSize().height );
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild(%s) natural size(%f, %f)\n",
+                   control.GetName().c_str(), control.GetNaturalSize().width, control.GetNaturalSize().height );
   }
 #endif
 
+
   // Get last stored width and height specifications for the child
   auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
   auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild desiredWidth(%d) desiredHeight(%d)\n", desiredWidth, desiredHeight );
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChild child WIDTH_SPEC(%d) child HEIGHT SPEC(%d)\n", desiredWidth, desiredHeight );
 
   auto padding = GetPadding(); // Padding of this layout's owner, not of the child being measured.
 
@@ -266,16 +374,16 @@ void LayoutGroup::MeasureChildWithMargins( LayoutItemPtr child,
 
   auto padding = GetPadding(); // Padding of this layout's owner, not of the child being measured.
 
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins desiredWidth(%d)\n",  desiredWidth );
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins child WIDTH_SPEC(%d)\n",  desiredWidth );
 
   MeasureSpec childWidthMeasureSpec = GetChildMeasureSpec( parentWidthMeasureSpec,
-                                                           padding.start + padding.end +
+                                                           LayoutLength( padding.start + padding.end ) +
                                                            widthUsed, desiredWidth );
 
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins desiredHeight(%d)\n",  desiredHeight );
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::MeasureChildWithMargins child HEIGHT_SPEC(%d)\n",  desiredHeight );
 
   MeasureSpec childHeightMeasureSpec = GetChildMeasureSpec( parentHeightMeasureSpec,
-                                                            padding.top + padding.bottom +
+                                                            LayoutLength( padding.top + padding.bottom )+
                                                             heightUsed, desiredHeight );
 
   child->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
@@ -290,12 +398,14 @@ MeasureSpec LayoutGroup::GetChildMeasureSpec(
   auto specMode = measureSpec.GetMode();
   LayoutLength specSize = measureSpec.GetSize();
 
-  auto size = std::max( LayoutLength(0), specSize - padding ); // reduce available size by the owners padding
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec childDimension(%f)\n", childDimension.AsInteger() );
+
+  LayoutLength size = std::max( LayoutLength(0), specSize - padding ); // reduce available size by the owners padding
 
-  MeasureSpec::IntType resultSize = 0;
+  LayoutLength resultSize = 0;
   MeasureSpec::Mode resultMode = MeasureSpec::Mode::UNSPECIFIED;
 
-  switch( specMode )
+  switch( specMode ) // Parents specMode
   {
     // Parent has imposed an exact size on us
     case MeasureSpec::Mode::EXACTLY:
@@ -384,8 +494,7 @@ MeasureSpec LayoutGroup::GetChildMeasureSpec(
     }
   }
 
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec resultSize(%u)\n", resultSize );
-
+  DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::GetChildMeasureSpec resultSize(" << resultSize << ")\n" );
 
   //noinspection ResourceType
   return MeasureSpec( resultSize, resultMode );
@@ -401,12 +510,11 @@ void LayoutGroup::OnInitialize()
     // Take ownership of existing children
     for( unsigned int childIndex = 0 ; childIndex < control.GetChildCount(); ++childIndex )
     {
-      ChildAddedToOwner( control.GetChildAt( childIndex ) );
+      ChildAddedToOwnerImpl( control.GetChildAt( childIndex ) );
     }
 
     DevelActor::ChildAddedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildAddedToOwner );
     DevelActor::ChildRemovedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildRemovedFromOwner );
-    DevelActor::ChildOrderChangedSignal( control ).Connect( mSlotDelegate, &LayoutGroup::ChildOrderChanged );
     DevelHandle::PropertySetSignal( control ).Connect( mSlotDelegate, &LayoutGroup::OnOwnerPropertySet );
 
     if( control.GetParent() )
@@ -418,10 +526,35 @@ void LayoutGroup::OnInitialize()
         if( parentLayout )
         {
           Internal::LayoutGroup& parentLayoutImpl = GetImplementation( parentLayout );
-          parentLayoutImpl.Add( *this );
+
+          unsigned int count = parent.GetChildCount();
+          unsigned int index = static_cast< unsigned int >( control.GetProperty< int >( DevelActor::Property::SIBLING_ORDER ) );
+
+          // Find insertion position
+          while( ++index < count )
+          {
+            auto sibling = Toolkit::Control::DownCast( parent.GetChildAt( index ) );
+            if( sibling )
+            {
+              auto siblingLayout = DevelControl::GetLayout( sibling );
+              if( siblingLayout )
+              {
+                Internal::LayoutItem& siblingLayoutImpl = GetImplementation( siblingLayout );
+                parentLayoutImpl.Insert( siblingLayoutImpl, *this );
+                break;
+              }
+            }
+          }
+
+          if( index >= count )
+          {
+            parentLayoutImpl.Add( *this );
+          }
         }
       }
     }
+
+    RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_OWNER_SET );
   }
 }
 
@@ -435,24 +568,38 @@ void LayoutGroup::OnUnparent()
   // Remove children
   RemoveAll();
 
-  // Remove myself from parent
-  LayoutParent* parent = GetParent();
-  if( parent )
+  auto control = Toolkit::Control::DownCast( GetOwner() );
+  if( control )
   {
-    LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( parent ) );
-    if( parentGroup )
-    {
-      parentGroup->Remove( *this );
-    }
+    DevelActor::ChildAddedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildAddedToOwner );
+    DevelActor::ChildRemovedSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::ChildRemovedFromOwner );
+    DevelHandle::PropertySetSignal( control ).Disconnect( mSlotDelegate, &LayoutGroup::OnOwnerPropertySet );
   }
 }
 
+void LayoutGroup::RemoveChild( LayoutItem& item )
+{
+  item.SetParent( nullptr );
+  OnChildRemove( item );
+}
+
 void LayoutGroup::ChildAddedToOwner( Actor child )
 {
+  ChildAddedToOwnerImpl( child );
+  RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_CHILD_ADD, child, Actor() );
+}
+
+void LayoutGroup::ChildAddedToOwnerImpl( Actor child )
+{
   LayoutItemPtr childLayout;
   Toolkit::Control control = Toolkit::Control::DownCast( child );
 
-  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner control(%s)\n", control?control.GetName().c_str():"Invalid" );
+#if defined(DEBUG_ENABLED)
+  auto parent = Toolkit::Control::DownCast( GetOwner() );
+  DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control(%s) owner control(%s)\n",
+                                              control?control.GetName().c_str():"Invalid",
+                                              parent?parent.GetName().c_str():"Invalid" );
+#endif
 
   if( control ) // Can only support adding Controls, not Actors to layout
   {
@@ -462,31 +609,52 @@ void LayoutGroup::ChildAddedToOwner( Actor child )
 
     if( ! childLayout )
     {
-      // If the child doesn't already have a layout, then create a LayoutItem for it.
-      childLayout = LayoutItem::New( control );
-      childLayout->SetAnimateLayout( IsLayoutAnimated() ); // @todo this essentially forces animation inheritance. Bad?
-#if defined(DEBUG_ENABLED)
-      auto desiredSize = control.GetNaturalSize();
-      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner desiredSize(%f,%f) (naturalSize)\n", desiredSize.width, desiredSize.height );
-#endif
+      // If the child doesn't already have a layout, then create a LayoutItem or LayoutGroup for it.
+      // If control behaviour flag set to Layout then set a LayoutGroup.
+      if( DevelControl::IsLayoutingRequired( control ) )
+      {
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutGroup for control:%s\n",
+                                                    control?control.GetName().c_str():"Invalid" );
+        childLayout = LayoutGroup::New( control );
+      }
+      else
+      {
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner Creating default LayoutItem for control:%s\n",
+                                                    control?control.GetName().c_str():"Invalid" );
+        childLayout = LayoutItem::New( control );
+        childLayout->SetAnimateLayout( IsLayoutAnimated() ); // forces animation inheritance.
+      }
+
+      DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child control:" <<  control.GetName() <<
+                       " desiredWidth: " <<  control.GetNaturalSize().width <<
+                       " desiredHeight:"  << control.GetNaturalSize().height );
+
       childControlDataImpl.SetLayout( *childLayout.Get() );
 
       Vector3 size = child.GetTargetSize();
       // If the size of the control is set explicitly make sure that the control size
       // stays the same after the layout except it is over written with match parent specs.
-      if ( size.x != 0 )
+
+      auto childControl = Toolkit::Control::DownCast(childLayout->GetOwner());
+
+      bool setWidthExplictly = ( childControl.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ) > 0  );
+      if ( size.x != 0 || setWidthExplictly )
       {
-        childLayout->SetMinimumWidth( size.x );
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner SetTargetWidth(%f)\n", size.x );
+        childLayout->SetTargetWidth( size.x );
       }
 
-      if ( size.y != 0 )
+      bool setHeightExplcitly = ( childControl.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION ) > 0 );
+      if ( size.y != 0 || setHeightExplcitly )
       {
-        childLayout->SetMinimumHeight( size.y );
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner SetTargetHeight(%f)\n", size.y);
+        childLayout->SetTargetHeight( size.y );
       }
       // Default layout data will be generated by Add().
     }
     else
     {
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::ChildAddedToOwner child(%s) already has a Layout\n", control.GetName().c_str() );
       LayoutGroupPtr layoutGroup( dynamic_cast< LayoutGroup* >( childLayout.Get() ) );
       if( !layoutGroup )
       {
@@ -510,17 +678,44 @@ void LayoutGroup::ChildRemovedFromOwner( Actor child )
     if( childLayout )
     {
       Remove( *childLayout.Get() );
+      RequestLayout( Dali::Toolkit::LayoutTransitionData::Type::ON_CHILD_REMOVE, child, Actor() );
     }
   }
 }
 
-void LayoutGroup::ChildOrderChanged()
+void LayoutGroup::ChildOrderChanged( Actor child )
 {
-  RequestLayout();
-  // Force Children to be relaid out:
-  for( auto&& child : mImpl->mChildren )
+  Toolkit::Control childControl = Toolkit::Control::DownCast( child );
+  if( childControl )
   {
-    child.child->SetLayoutRequested();
+    Internal::Control& childControlImpl = GetImplementation( childControl );
+    Internal::Control::Impl& childControlDataImpl = Internal::Control::Impl::Get( childControlImpl );
+
+    auto childLayout = childControlDataImpl.GetLayout();
+    if( childLayout )
+    {
+      Toolkit::Control control = Toolkit::Control::DownCast( GetOwner() );
+      unsigned int count = control.GetChildCount();
+      unsigned int index = static_cast< unsigned int >( childControl.GetProperty< int >( DevelActor::Property::SIBLING_ORDER ) );
+
+      // Find insertion position
+      while( ++index < count )
+      {
+        auto sibling = Toolkit::Control::DownCast( control.GetChildAt( index ) );
+        if( sibling )
+        {
+          auto siblingLayout = DevelControl::GetLayout( sibling );
+          if( siblingLayout )
+          {
+            Internal::LayoutItem& siblingLayoutImpl = GetImplementation( siblingLayout );
+            Move( siblingLayoutImpl, *childLayout );
+            return;
+          }
+        }
+      }
+
+      MoveBack( *childLayout );
+    }
   }
 }
 
@@ -546,7 +741,7 @@ void LayoutGroup::OnAnimationStateChanged( bool animateLayout )
   for( auto&& child : mImpl->mChildren )
   {
     LayoutGroupPtr parentGroup( dynamic_cast< LayoutGroup* >( child.child.Get() ) );
-    if( !parentGroup )
+    if( ! parentGroup )
     {
       // Change state only in case of leaf children
       child.child->SetAnimateLayout( animateLayout );
@@ -554,6 +749,192 @@ void LayoutGroup::OnAnimationStateChanged( bool animateLayout )
   }
 }
 
+void LayoutGroup::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
+{
+  auto childCount = GetChildCount();
+
+  DALI_LOG_STREAM( gLogFilter, Debug::Verbose,
+                  "LayoutGroup::OnMeasure Actor Id:" <<  Actor::DownCast(GetOwner()).GetId() <<
+                  " Owner:" <<  Actor::DownCast(GetOwner()).GetName() <<
+                  " Child Count:" << childCount <<
+                  " MeasureSpecs( width:"<<widthMeasureSpec<<", height:"<<heightMeasureSpec );
+
+  auto widthMode = widthMeasureSpec.GetMode();
+  auto heightMode = heightMeasureSpec.GetMode();
+  LayoutLength widthSpecSize = widthMeasureSpec.GetSize();
+  LayoutLength heightSpecSize = heightMeasureSpec.GetSize();
+
+  bool exactWidth ( false );
+  bool exactHeight ( false );
+
+  // Layouting behaviour
+  // EXACT, width and height as provided.
+  // MATCH_PARENT, width and height that of parent
+  // WRAP_CONTENT, take width of widest child and height size of longest child (within given limit)
+  // UNSPECIFIED, take width of widest child and height size of longest child.
+
+  LayoutLength layoutWidth( 0 );
+  LayoutLength layoutHeight( 0 );
+
+  // If LayoutGroup has children then measure children to get max dimensions
+  if ( childCount > 0 )
+  {
+    for( unsigned int i=0; i<childCount; ++i )
+    {
+      auto childLayout = GetChildAt( i );
+      if( childLayout )
+      {
+        auto childControl = Toolkit::Control::DownCast(childLayout->GetOwner());
+
+        // If child control has children check if a ResizePolicy is set on it.  A LayoutItem could be a legacy container.
+        // A legacy container would need it's ResizePolicy to be applied as a MeasureSpec.
+
+        // Check below will be true for legacy containers and controls with layout required set.
+        // Other layouts will have their own OnMeasure (a checked requirement) hence not execute LayoutGroup::OnMeasure.
+        // Controls which have set layout required will not be legacy controls hence should not have a ResizePolicy set.
+        // Only need to map the resize policy the first time as the Layouting system will then set it to FIXED.
+        if( childControl.GetChildCount() > 0 && ! mImpl->mResizePolicyMapped )
+        {
+          // First pass, Static mappings that are not dependant on parent
+          SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::WIDTH );
+          SizeNegotiationMapper::SetLayoutParametersUsingResizePolicy( childControl, childLayout, Dimension::HEIGHT );
+          mImpl->mResizePolicyMapped = true;
+        }
+
+        // Second pass, if any mappings were not possible due to parent size dependancies then calculate an exact desired size for child
+        if( true == childLayout->IsResizePolicyRequired() ) // No need to test child count as this flag would only be set if control had children.
+        {
+          // Get last stored width and height specifications for the child
+          LayoutLength desiredWidth = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+          LayoutLength desiredHeight = childControl.GetProperty<float>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
+
+          DALI_LOG_INFO( gLogFilter, Debug::General, "LayoutGroup::MeasureChild Initial desired size pre ResizePolicy(%f,%f)\n", desiredWidth.AsInteger(), desiredHeight.AsInteger() );
+
+          childLayout->SetResizePolicyRequired( false ); // clear flag incase in case of changes before next Measure
+          SizeNegotiationMapper::GetSizeofChildForParentDependentResizePolicy( childControl, widthMeasureSpec, heightMeasureSpec, desiredWidth, desiredHeight );
+
+          // Parent dependant ResizePolicies become exact sizes so are now set on the child before it's measured.
+          childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, desiredWidth.AsInteger() );
+          childControl.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, desiredHeight.AsInteger()  );
+
+          DALI_LOG_INFO( gLogFilter, Debug::General, " LayoutGroup::OnMeasure ResizePolicy Required resulting size(%f,%f)\n",  desiredWidth.AsInteger(), desiredHeight.AsInteger() );
+        }
+
+        // Get size of child
+        MeasureChild( childLayout, widthMeasureSpec, heightMeasureSpec );
+        LayoutLength childWidth = childLayout->GetMeasuredWidth();
+        LayoutLength childHeight = childLayout->GetMeasuredHeight();
+
+        Extents childMargin = childLayout->GetMargin();
+        DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure child " << childControl.GetName().c_str() << " width[" << childWidth << "] height[" << childHeight << "]\n" );
+
+        layoutWidth = std::max( layoutWidth, childWidth + childMargin.start + childMargin.end );
+        layoutHeight = std::max( layoutHeight, childHeight + childMargin.top + childMargin.bottom );
+        DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure calculated child width[" << layoutWidth << "] height[" << layoutHeight << "]\n" );
+      }
+      else
+      {
+        DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Not a layout\n" );
+      }
+    }
+
+    Extents padding = GetPadding();
+    layoutWidth += padding.start + padding.end;
+    layoutHeight += padding.top + padding.bottom;
+  }
+  else
+  {
+    DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnMeasure Getting default size as a leaf\n" );
+    // LayoutGroup does not contain any children so must be a leaf
+    layoutWidth = GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec );
+    layoutHeight = GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec );
+  }
+
+  // Can't exceed specified width
+  if( widthMode == MeasureSpec::Mode::EXACTLY )
+  {
+    exactWidth = true;
+  }
+  else if ( widthMode == MeasureSpec::Mode::AT_MOST )
+  {
+    layoutWidth = std::min( layoutWidth, widthSpecSize );
+  }
+
+  // Can't exceed specified height
+  if( heightMode == MeasureSpec::Mode::EXACTLY )
+  {
+    exactHeight = true;
+  }
+  else if ( heightMode == MeasureSpec::Mode::AT_MOST )
+  {
+    layoutHeight = std::min( layoutHeight, heightSpecSize );
+  }
+
+  layoutWidth = std::max( layoutWidth, GetSuggestedMinimumWidth() );
+  layoutHeight = std::max( layoutHeight, GetSuggestedMinimumHeight() );
+
+  if( exactWidth )
+  {
+    layoutWidth = widthSpecSize;
+  }
+
+  if( exactHeight )
+  {
+    layoutHeight = heightSpecSize;
+  }
+
+  DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnMeasure Measured size(" << layoutWidth << "," << layoutHeight << ") for : " << Actor::DownCast(GetOwner()).GetName() << " \n" );
+  SetMeasuredDimensions( MeasuredSize( layoutWidth ), MeasuredSize( layoutHeight ) );
+}
+
+void LayoutGroup::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
+{
+  auto count = GetChildCount();
+
+  DALI_LOG_STREAM( gLogFilter, Debug::Verbose, "LayoutGroup OnLayout owner:" << ( ( Toolkit::Control::DownCast(GetOwner())) ? Toolkit::Control::DownCast(GetOwner()).GetName() : "invalid" )  << " childCount:" << count );
+
+  for( unsigned int childIndex = 0; childIndex < count; childIndex++)
+  {
+    LayoutItemPtr childLayout = GetChildAt( childIndex );
+    if( childLayout != nullptr )
+    {
+
+      auto childOwner = childLayout->GetOwner();
+      if( !childLayout->IsLayoutAnimated() )
+      {
+        Actor actor = Actor::DownCast( childOwner );
+        if ( actor && DevelActor::IsPositionOrSizeCurrentlyAnimating( actor ) )
+        {
+          continue;
+        }
+      }
+
+      LayoutLength childWidth = childLayout->GetMeasuredWidth();
+      LayoutLength childHeight = childLayout->GetMeasuredHeight();
+      Extents childMargin = childLayout->GetMargin();
+      auto control = Toolkit::Control::DownCast( childOwner );
+      Extents padding = GetPadding();
+
+      auto childPosition = control.GetProperty< Vector3 >( Actor::Property::POSITION );
+      auto anchorPoint = control.GetProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
+
+      DALI_LOG_STREAM( gLogFilter, Debug::General, "LayoutGroup::OnLayout child[" << control.GetName() <<
+                       "] position(" << childPosition << ") child width[" << childWidth << "] height[" << childHeight << "]\n" );
+
+      // Margin and Padding only supported when child anchor point is TOP_LEFT.
+      int paddingAndMarginOffsetX = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.top + childMargin.top ) : 0;
+      int paddingAndMarginOffsetY = ( AnchorPoint::TOP_LEFT == anchorPoint ) ? ( padding.start + childMargin.start ) : 0;
+      DALI_LOG_INFO( gLogFilter, Debug::Verbose, "LayoutGroup::OnLayout paddingMargin offset(%d,%d)\n", paddingAndMarginOffsetX, paddingAndMarginOffsetY );
+
+      LayoutLength childLeft = childPosition.x + paddingAndMarginOffsetX;
+      LayoutLength childTop = childPosition.y + paddingAndMarginOffsetY;
+
+      childLayout->Layout( childLeft, childTop, childLeft + childWidth, childTop + childHeight );
+    }
+  }
+}
+
+
 } // namespace Internal
 } // namespace Toolkit
 } // namespace Dali