dali-toolkit/internal/layouting/flex-layout-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 "flex-layout-impl.h"
  19
  20 //EXTERNAL INCLUDES
  21 #include <dali/integration-api/debug.h>
  22 #include <dali/public-api/common/extents.h>
  23 #include <dali/devel-api/actors/actor-devel.h>
  24 #include <dali/devel-api/object/handle-devel.h>
  25
  26 //INTERNAL INCLUDES
  27 #include <dali-toolkit/devel-api/layouting/layout-item.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/third-party/yoga/YGNode.h>
  31
  32 #if defined(DEBUG_ENABLED)
  33 static Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_LAYOUT" );
  34 #endif
  35
  36 namespace Dali
  37 {
  38 namespace Toolkit
  39 {
  40 namespace Internal
  41 {
  42
  43 FlexLayoutPtr FlexLayout::New()
  44 {
  45   FlexLayoutPtr layout( new FlexLayout() );
  46   return layout;
  47 }
  48
  49 void FlexLayout::SetFlexDirection( Dali::Toolkit::FlexLayout::FlexDirection flexDirection )
  50 {
  51   YGNodeStyleSetFlexDirection( mRoot, static_cast<YGFlexDirection>(flexDirection) );
  52 }
  53
  54 Dali::Toolkit::FlexLayout::FlexDirection FlexLayout::GetFlexDirection() const
  55 {
  56   return static_cast<Dali::Toolkit::FlexLayout::FlexDirection>(YGNodeStyleGetFlexDirection( mRoot ));
  57 }
  58
  59 void FlexLayout::SetFlexJustification( Dali::Toolkit::FlexLayout::Justification flexJustification )
  60 {
  61   YGNodeStyleSetJustifyContent( mRoot, static_cast<YGJustify>(flexJustification) );
  62 }
  63
  64 Dali::Toolkit::FlexLayout::Justification FlexLayout::GetFlexJustification() const
  65 {
  66   return static_cast<Dali::Toolkit::FlexLayout::Justification>(YGNodeStyleGetJustifyContent( mRoot ));
  67 }
  68
  69 void FlexLayout::SetFlexWrap( Dali::Toolkit::FlexLayout::WrapType wrapType )
  70 {
  71   YGNodeStyleSetFlexWrap( mRoot, static_cast<YGWrap>(wrapType) );
  72 }
  73
  74 Dali::Toolkit::FlexLayout::WrapType FlexLayout::GetFlexWrap() const
  75 {
  76   return static_cast<Dali::Toolkit::FlexLayout::WrapType>(YGNodeStyleGetFlexWrap( mRoot ));
  77 }
  78
  79 void FlexLayout::SetFlexAlignment( Dali::Toolkit::FlexLayout::Alignment::Type flexAlignment )
  80 {
  81   YGNodeStyleSetAlignContent( mRoot, static_cast<YGAlign>(flexAlignment) );
  82 }
  83
  84 Dali::Toolkit::FlexLayout::Alignment::Type FlexLayout::GetFlexAlignment() const
  85 {
  86   return static_cast<Dali::Toolkit::FlexLayout::Alignment::Type>(YGNodeStyleGetAlignContent( mRoot ));
  87 }
  88
  89 void FlexLayout::SetFlexItemsAlignment( Dali::Toolkit::FlexLayout::Alignment::Type flexAlignment )
  90 {
  91   YGNodeStyleSetAlignItems( mRoot, static_cast<YGAlign>(flexAlignment) );
  92 }
  93
  94 Dali::Toolkit::FlexLayout::Alignment::Type FlexLayout::GetFlexItemsAlignment() const
  95 {
  96   return static_cast<Dali::Toolkit::FlexLayout::Alignment::Type>(YGNodeStyleGetAlignItems( mRoot ));
  97 }
  98
  99 FlexLayout::FlexLayout()
 100 : LayoutGroup(),
 101   mRoot( nullptr )
 102 {
 103   mRoot = YGNodeNew();
 104   YGNodeSetContext( mRoot, this );
 105
 106   // Set default style
 107   YGNodeStyleSetFlexDirection( mRoot, YGFlexDirectionColumn );
 108   YGNodeStyleSetFlexWrap( mRoot, YGWrapNoWrap );
 109   YGNodeStyleSetJustifyContent( mRoot, YGJustifyFlexStart );
 110   YGNodeStyleSetAlignContent( mRoot, YGAlignFlexStart );
 111   YGNodeStyleSetAlignItems( mRoot, YGAlignFlexStart );
 112 }
 113
 114 FlexLayout::~FlexLayout()
 115 {
 116   if( mRoot )
 117   {
 118     YGNodeFreeRecursive( mRoot );
 119   }
 120 }
 121
 122 void FlexLayout::DoInitialize()
 123 {
 124 }
 125
 126 void FlexLayout::DoRegisterChildProperties( const std::string& containerType )
 127 {
 128   auto typeInfo = Dali::TypeRegistry::Get().GetTypeInfo( containerType );
 129   if( typeInfo )
 130   {
 131     Property::IndexContainer indices;
 132     typeInfo.GetChildPropertyIndices( indices );
 133
 134     if( std::find( indices.Begin(), indices.End(), Toolkit::FlexLayout::ChildProperty::FLEX ) ==
 135         indices.End() )
 136     {
 137       ChildPropertyRegistration( typeInfo.GetName(), "flex", Toolkit::FlexLayout::ChildProperty::FLEX, Property::FLOAT );
 138     }
 139
 140     if( std::find( indices.Begin(), indices.End(), Toolkit::FlexLayout::ChildProperty::ALIGN_SELF ) ==
 141         indices.End() )
 142     {
 143       ChildPropertyRegistration( typeInfo.GetName(), "alignSelf", Toolkit::FlexLayout::ChildProperty::ALIGN_SELF, Property::INTEGER );
 144     }
 145   }
 146 }
 147
 148 void FlexLayout::OnChildAdd( LayoutItem& child )
 149 {
 150   auto owner = child.GetOwner();
 151   if(!DevelHandle::DoesCustomPropertyExist(owner, Toolkit::FlexLayout::ChildProperty::FLEX ))
 152   {
 153     owner.SetProperty( Toolkit::FlexLayout::ChildProperty::FLEX, 0 );
 154   }
 155   if(!DevelHandle::DoesCustomPropertyExist(owner, Toolkit::FlexLayout::ChildProperty::ALIGN_SELF ))
 156   {
 157     owner.SetProperty( Toolkit::FlexLayout::ChildProperty::ALIGN_SELF, YGAlignAuto );
 158   }
 159
 160   YGNodeRef node = YGNodeNew();
 161   YGNodeSetContext( node, &child );
 162   YGNodeSetMeasureFunc( node, OnChildMeasure );
 163   YGNodeMarkDirty( node );
 164   YGNodeInsertChild( mRoot, node, GetChildCount()-1 );
 165 }
 166
 167 void FlexLayout::OnChildRemove( LayoutItem& child )
 168 {
 169   auto count = GetChildCount();
 170   for( unsigned int childIndex = 0; childIndex < count; childIndex++)
 171   {
 172     LayoutItemPtr childLayout = GetChildAt( childIndex );
 173     if( &child == childLayout.Get() )
 174     {
 175       YGNodeRef node = YGNodeGetChild( mRoot, childIndex );
 176       YGNodeRemoveChild( mRoot, node );
 177       break;
 178     }
 179   }
 180 }
 181
 182 void FlexLayout::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
 183 {
 184   auto actor = Actor::DownCast(GetOwner());
 185   bool isLayoutRtl = actor ? actor.GetProperty<int>( Actor::Property::LAYOUT_DIRECTION ) == LayoutDirection::RIGHT_TO_LEFT: false;
 186   Extents padding = GetPadding();
 187   Extents margin = GetMargin();
 188
 189 #if defined(DEBUG_ENABLED)
 190   std::ostringstream oss;
 191   oss << "FlexLayout::OnMeasure  ";
 192   if( actor )
 193   {
 194     oss << "Actor Id:" << actor.GetId() << " Name:" << actor.GetName() << " Layout direction:" << actor.GetProperty( Actor::Property::LAYOUT_DIRECTION ).Get<int>() << " ";
 195   }
 196   oss << "widthMeasureSpec:" << widthMeasureSpec << " heightMeasureSpec:" << heightMeasureSpec << std::endl;
 197   DALI_LOG_INFO( gLogFilter, Debug::Concise, oss.str().c_str() );
 198 #endif
 199
 200   YGNodeStyleSetMargin( mRoot, YGEdgeLeft, margin.start );
 201   YGNodeStyleSetMargin( mRoot, YGEdgeTop, margin.top );
 202   YGNodeStyleSetMargin( mRoot, YGEdgeRight, margin.end );
 203   YGNodeStyleSetMargin( mRoot, YGEdgeBottom, margin.bottom );
 204   YGNodeStyleSetPadding( mRoot, YGEdgeLeft, padding.start );
 205   YGNodeStyleSetPadding( mRoot, YGEdgeTop, padding.top );
 206   YGNodeStyleSetPadding( mRoot, YGEdgeRight, padding.end );
 207   YGNodeStyleSetPadding( mRoot, YGEdgeBottom, padding.bottom );
 208
 209   float width = YGUndefined;
 210   float height = YGUndefined;
 211
 212   YGNodeStyleSetWidth( mRoot, YGUndefined );
 213   YGNodeStyleSetHeight( mRoot, YGUndefined );
 214   YGNodeStyleSetMinWidth( mRoot, YGUndefined );
 215   YGNodeStyleSetMinHeight( mRoot, YGUndefined );
 216   YGNodeStyleSetMaxWidth( mRoot, YGUndefined );
 217   YGNodeStyleSetMaxHeight( mRoot, YGUndefined );
 218
 219   if( widthMeasureSpec.GetMode() == MeasureSpec::Mode::EXACTLY )
 220   {
 221     width = widthMeasureSpec.GetSize();
 222     YGNodeStyleSetWidth( mRoot, width );
 223   }
 224   else if( widthMeasureSpec.GetMode() == MeasureSpec::Mode::AT_MOST )
 225   {
 226     width = widthMeasureSpec.GetSize();
 227     YGNodeStyleSetMaxWidth( mRoot, width );
 228   }
 229
 230   if ( heightMeasureSpec.GetMode() == MeasureSpec::Mode::EXACTLY )
 231   {
 232     height = heightMeasureSpec.GetSize();
 233     YGNodeStyleSetHeight( mRoot, height );
 234   }
 235   else if ( heightMeasureSpec.GetMode() == MeasureSpec::Mode::AT_MOST )
 236   {
 237     height = heightMeasureSpec.GetSize();
 238     YGNodeStyleSetMaxHeight( mRoot, height );
 239   }
 240
 241   SetChildrenStyle();
 242   YGNodeCalculateLayout( mRoot, width, height, isLayoutRtl ? YGDirectionRTL : YGDirectionLTR );
 243   SetMeasuredDimensions( GetDefaultSize( YGNodeLayoutGetWidth(mRoot), widthMeasureSpec ),
 244                          GetDefaultSize( YGNodeLayoutGetHeight(mRoot), heightMeasureSpec ) );
 245 }
 246
 247 void FlexLayout::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
 248 {
 249   auto owner = GetOwner();
 250   auto actor = Actor::DownCast(owner);
 251   bool isLayoutRtl = actor ? actor.GetProperty( Actor::Property::LAYOUT_DIRECTION ).Get<int>() == LayoutDirection::RIGHT_TO_LEFT: false;
 252   auto width = right - left;
 253   auto height = bottom - top;
 254
 255 #if defined(DEBUG_ENABLED)
 256   std::ostringstream oss;
 257   oss << "FlexLayout::OnLayout  ";
 258   if( actor )
 259   {
 260     oss << "Actor Id:" << actor.GetId() << " Name:" << actor.GetName() << " Layout direction:" << actor.GetProperty( Actor::Property::LAYOUT_DIRECTION ).Get<int>() << " ";
 261   }
 262   oss << "changed:" << (int)changed << " left:" << left << " top:" << top << " right:" << right << " bottom:" << bottom << " isLayoutRtl:" << (int)isLayoutRtl << std::endl;
 263   DALI_LOG_INFO( gLogFilter, Debug::Concise, oss.str().c_str() );
 264 #endif
 265
 266   YGNodeCalculateLayout( mRoot, width, height, isLayoutRtl ? YGDirectionRTL : YGDirectionLTR );
 267
 268   auto count = GetChildCount();
 269   for( unsigned int childIndex = 0; childIndex < count; childIndex++)
 270   {
 271     LayoutItemPtr childLayout = GetChildAt( childIndex );
 272     if( childLayout != nullptr )
 273     {
 274       YGNodeRef node = YGNodeGetChild(mRoot, childIndex);
 275       auto childLeft = YGNodeLayoutGetLeft( node ) + left;
 276       auto childTop = YGNodeLayoutGetTop( node ) + top;
 277       auto childWidth = YGNodeLayoutGetWidth( node );
 278       auto childHeight = YGNodeLayoutGetHeight( node );
 279       childLayout->Layout( childLeft, childTop, childLeft + childWidth, childTop + childHeight );
 280     }
 281   }
 282 }
 283
 284 YGSize FlexLayout::OnChildMeasure( YGNodeRef node,
 285                               float innerWidth,
 286                               YGMeasureMode widthMode,
 287                               float innerHeight,
 288                               YGMeasureMode heightMode ) {
 289   LayoutItem* childLayout = static_cast<LayoutItem*>(node->getContext());
 290   auto childOwner = childLayout->GetOwner();
 291   auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
 292   auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
 293   auto parentWidthMeasureSpec = MeasureSpec( 0 );
 294   if ( innerWidth != YGUndefined )
 295   {
 296     parentWidthMeasureSpec = MeasureSpec( innerWidth, static_cast<MeasureSpec::Mode>(widthMode) );
 297   }
 298   auto parentHeightMeasureSpec = MeasureSpec( 0 );
 299   if ( innerHeight != YGUndefined )
 300   {
 301     parentHeightMeasureSpec = MeasureSpec( innerHeight, static_cast<MeasureSpec::Mode>(heightMode) );
 302   }
 303   auto childWidthMeasureSpec = LayoutGroup::GetChildMeasureSpec( parentWidthMeasureSpec, 0, desiredWidth);
 304   auto childHeightMeasureSpec = LayoutGroup::GetChildMeasureSpec( parentHeightMeasureSpec, 0, desiredHeight);
 305
 306   // Force to fill parent if a child wants to match parent even if GetChildMeasureSpec sets otherwise
 307   if( desiredWidth == Toolkit::ChildLayoutData::MATCH_PARENT && innerWidth != YGUndefined )
 308   {
 309     childWidthMeasureSpec = MeasureSpec( innerWidth, MeasureSpec::Mode::EXACTLY );
 310   }
 311   if( desiredHeight == Toolkit::ChildLayoutData::MATCH_PARENT && innerHeight != YGUndefined )
 312   {
 313     childHeightMeasureSpec = MeasureSpec( innerHeight, MeasureSpec::Mode::EXACTLY );
 314   }
 315
 316 #if defined(DEBUG_ENABLED)
 317   auto actor = Actor::DownCast(childOwner);
 318   std::ostringstream oss;
 319   oss << "FlexLayout::OnChildMeasure  ";
 320   if( actor )
 321   {
 322     oss << "Actor Id:" << actor.GetId() << " Name:" << actor.GetName() << " ";
 323   }
 324   oss << "innerWidth:" << ( ( innerWidth == YGUndefined ) ? "YGUndefined " : "" ) << innerWidth <<
 325          " innerHeight:" << ( ( innerHeight == YGUndefined ) ? "YGUndefined " : "" ) << innerHeight <<
 326          " desiredWidth:" << desiredWidth << " desiredHeight:" << desiredHeight <<
 327          " childWidthMeasureSpec:" << childWidthMeasureSpec << " childHeightMeasureSpec:" << childHeightMeasureSpec << std::endl;
 328   DALI_LOG_INFO( gLogFilter, Debug::Concise, oss.str().c_str() );
 329 #endif
 330
 331   childLayout->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
 332
 333   // Remove padding here since Yoga doesn't consider it as a part of the node size
 334   Extents padding = childLayout->GetPadding();
 335   auto measuredWidth = childLayout->GetMeasuredWidth() - padding.end - padding.start;
 336   auto measuredHeight = childLayout->GetMeasuredHeight() - padding.bottom - padding.top;
 337
 338   return YGSize{
 339     .width = measuredWidth,
 340     .height = measuredHeight,
 341   };
 342 }
 343
 344 void FlexLayout::SetChildrenStyle()
 345 {
 346   if( mRoot )
 347   {
 348     auto count = GetChildCount();
 349     for( unsigned int childIndex = 0; childIndex < count; childIndex++)
 350     {
 351       LayoutItemPtr childLayout = GetChildAt( childIndex );
 352       if( childLayout != nullptr )
 353       {
 354         Extents padding = childLayout->GetPadding();
 355         Extents margin = childLayout->GetMargin();
 356         auto childOwner = childLayout->GetOwner();
 357         auto childActor = Actor::DownCast(childOwner);
 358         auto flex = childOwner.GetProperty<float>( Toolkit::FlexLayout::ChildProperty::FLEX );
 359         auto alignSelf = static_cast<YGAlign>( childOwner.GetProperty<int>( Toolkit::FlexLayout::ChildProperty::ALIGN_SELF ));
 360
 361         YGNodeRef childNode = YGNodeGetChild( mRoot, childIndex );
 362         // Initialise the style of the child.
 363         YGNodeStyleSetMargin( childNode, YGEdgeLeft, margin.start );
 364         YGNodeStyleSetMargin( childNode, YGEdgeTop, margin.top );
 365         YGNodeStyleSetMargin( childNode, YGEdgeRight, margin.end );
 366         YGNodeStyleSetMargin( childNode, YGEdgeBottom, margin.bottom );
 367
 368         YGNodeStyleSetPadding( childNode, YGEdgeLeft, padding.start );
 369         YGNodeStyleSetPadding( childNode, YGEdgeTop, padding.top );
 370         YGNodeStyleSetPadding( childNode, YGEdgeRight, padding.end );
 371         YGNodeStyleSetPadding( childNode, YGEdgeBottom, padding.bottom );
 372
 373         YGNodeStyleSetWidth( childNode, YGUndefined );
 374         YGNodeStyleSetHeight( childNode, YGUndefined );
 375         // TODO: check if we are supposed to use actor properties here, max/min is needed for stretch
 376         YGNodeStyleSetMinWidth( childNode, childActor.GetMinimumSize().x );
 377         YGNodeStyleSetMinHeight( childNode, childActor.GetMinimumSize().y );
 378         if( childActor.GetMaximumSize().x == FLT_MAX )
 379         {
 380           YGNodeStyleSetMaxWidth( childNode, YGUndefined );
 381         }
 382         else
 383         {
 384           YGNodeStyleSetMaxWidth( childNode, childActor.GetMaximumSize().x );
 385         }
 386         if( childActor.GetMaximumSize().y == FLT_MAX )
 387         {
 388           YGNodeStyleSetMaxHeight( childNode, YGUndefined );
 389         }
 390         else
 391         {
 392           YGNodeStyleSetMaxHeight( childNode, childActor.GetMaximumSize().y );
 393         }
 394
 395         YGNodeStyleSetFlex( childNode, flex );
 396         YGNodeStyleSetAlignSelf( childNode, alignSelf );
 397
 398         // Have to do manually for nodes with custom measure function
 399         // TODO: check the style is changed before marking the node
 400         YGNodeMarkDirty( childNode );
 401       }
 402     }
 403   }
 404 }
 405
 406 } // namespace Internal
 407 } // namespace Toolkit
 408 } // namespace Dali