dali-toolkit/devel-api/layouting/layout-item-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 #include <dali/integration-api/debug.h>
  18
  19 #include <dali/public-api/animation/animation.h>
  20 #include <dali/public-api/object/type-registry-helper.h>
  21 #include <dali-toolkit/public-api/controls/control.h>
  22 #include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
  23 #include <dali-toolkit/internal/layouting/layout-item-data-impl.h>
  24
  25 namespace
  26 {
  27
  28 #if defined(DEBUG_ENABLED)
  29 Debug::Filter* gLayoutFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_LAYOUT" );
  30 #endif
  31
  32 const char* WIDTH_SPECIFICATION_NAME( "widthSpecification" );
  33 const char* HEIGHT_SPECIFICATION_NAME( "heightSpecification" );
  34
  35 const float DEFAULT_TRANSITION_DURATION( 0.5f );
  36 }
  37
  38 namespace Dali
  39 {
  40 namespace Toolkit
  41 {
  42 namespace Internal
  43 {
  44
  45 LayoutItem::LayoutItem()
  46 : mImpl( new LayoutItem::Impl() ),
  47   mSlotDelegate( this )
  48 {
  49 }
  50
  51 LayoutItem::~LayoutItem()
  52 {
  53   // An object with a unique_ptr to an opaque structure must define it's destructor in the translation unit
  54   // where the opaque structure is defined. It cannot use the default method in the header file.
  55 }
  56
  57 LayoutItemPtr LayoutItem::New( Handle& owner )
  58 {
  59   LayoutItemPtr layoutPtr = new LayoutItem();
  60   return layoutPtr;
  61 }
  62
  63 void LayoutItem::Initialize( Handle& owner, const std::string& containerType )
  64 {
  65   mImpl->mOwner = &(owner.GetBaseObject());
  66   RegisterChildProperties( containerType );
  67   OnInitialize(); // Ensure direct deriving class gets initialized
  68   RequestLayout();
  69 }
  70
  71 Handle LayoutItem::GetOwner() const
  72 {
  73   return Handle::DownCast(BaseHandle(mImpl->mOwner));
  74 }
  75
  76 void LayoutItem::Unparent()
  77 {
  78   // Enable directly derived types to first remove children
  79   OnUnparent();
  80
  81   // Last, clear owner
  82   mImpl->mOwner = NULL;
  83 }
  84
  85 void LayoutItem::SetAnimateLayout( bool animateLayout )
  86 {
  87   mImpl->mAnimated = animateLayout;
  88
  89   OnAnimationStateChanged( animateLayout );
  90 }
  91
  92 bool LayoutItem::IsLayoutAnimated() const
  93 {
  94   return mImpl->mAnimated;
  95 }
  96
  97 void LayoutItem::RegisterChildProperties( const std::string& containerType )
  98 {
  99   // Call on derived types
 100   auto typeInfo = TypeRegistry::Get().GetTypeInfo( containerType );
 101   if( typeInfo )
 102   {
 103     Property::IndexContainer indices;
 104     typeInfo.GetChildPropertyIndices( indices );
 105
 106     if( std::find( indices.Begin(), indices.End(), Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ) ==
 107         indices.End() )
 108     {
 109       ChildPropertyRegistration( typeInfo.GetName(), WIDTH_SPECIFICATION_NAME,
 110                                  Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, Property::INTEGER );
 111
 112       ChildPropertyRegistration( typeInfo.GetName(), HEIGHT_SPECIFICATION_NAME,
 113                                  Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, Property::INTEGER );
 114     }
 115
 116     OnRegisterChildProperties( containerType );
 117   }
 118 }
 119
 120 void LayoutItem::OnRegisterChildProperties( const std::string& containerType )
 121 {
 122 }
 123
 124
 125 void LayoutItem::Measure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
 126 {
 127   DALI_LOG_TRACE_METHOD( gLayoutFilter );
 128
 129   const bool forceLayout = mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
 130
 131   const bool specChanged =
 132     ( widthMeasureSpec  != mImpl->mOldWidthMeasureSpec ) ||
 133     ( heightMeasureSpec != mImpl->mOldHeightMeasureSpec );
 134
 135   const bool isSpecExactly =
 136     ( widthMeasureSpec.GetMode() == MeasureSpec::Mode::EXACTLY ) &&
 137     ( heightMeasureSpec.GetMode() == MeasureSpec::Mode::EXACTLY );
 138
 139   const bool matchesSpecSize =
 140     ( GetMeasuredWidth() == widthMeasureSpec.GetSize() ) &&
 141     ( GetMeasuredHeight() == heightMeasureSpec.GetSize() );
 142
 143   const bool needsLayout = specChanged && ( !isSpecExactly || !matchesSpecSize );
 144
 145   DALI_LOG_STREAM( gLayoutFilter, Debug::Verbose, "LayoutItem::Measure("<<widthMeasureSpec<<", "<<heightMeasureSpec<<") Owner:"<<Actor::DownCast(GetOwner()).GetName() <<"  forceLayout="<<forceLayout<<", specChanged="<<specChanged<<", isSpecExactly="<<isSpecExactly<<", matchesSpecSize="<<matchesSpecSize<<", needsLayout="<<needsLayout <<std::endl <<(forceLayout||needsLayout?"  Remeasuring":"  NoChange"));
 146
 147   if( forceLayout || needsLayout )
 148   {
 149     mImpl->ClearPrivateFlag( Impl::PRIVATE_FLAG_MEASURED_DIMENSION_SET );
 150
 151     // measure ourselves, this should set the measured dimension flag back
 152 #if defined(DEBUG_ENABLED)
 153     std::ostringstream o;
 154     o<<widthMeasureSpec<<","<<heightMeasureSpec;
 155     DALI_LOG_INFO( gLayoutFilter, Debug::Concise, "Calling %s OnMeasure( %s )\n", Actor::DownCast(GetOwner()).GetName().c_str(), o.str().c_str());
 156 #endif
 157     OnMeasure( widthMeasureSpec, heightMeasureSpec );
 158     mImpl->ClearPrivateFlag( Impl::PRIVATE_FLAG_MEASURE_NEEDED_BEFORE_LAYOUT );
 159
 160     // flag not set, setMeasuredDimension() was not invoked, we raise an exception to warn the developer
 161     DALI_ASSERT_ALWAYS( mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_MEASURED_DIMENSION_SET ) &&
 162                         "Layout's OnMeasure() did not set the measured dimension by calling setMeasuredDimension()" );
 163     mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_LAYOUT_REQUIRED );
 164   }
 165
 166   mImpl->mOldWidthMeasureSpec = widthMeasureSpec;
 167   mImpl->mOldHeightMeasureSpec = heightMeasureSpec;
 168 }
 169
 170 void LayoutItem::Layout( LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b )
 171 {
 172   if( mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_MEASURE_NEEDED_BEFORE_LAYOUT ) )
 173   {
 174     OnMeasure( mImpl->mOldWidthMeasureSpec, mImpl->mOldHeightMeasureSpec );
 175     mImpl->ClearPrivateFlag( Impl::PRIVATE_FLAG_MEASURE_NEEDED_BEFORE_LAYOUT );
 176   }
 177
 178   bool changed = SetFrame( l, t, r, b );
 179
 180   if( changed || mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_LAYOUT_REQUIRED ) )
 181   {
 182     OnLayout( changed, l, t, r, b );
 183     mImpl->ClearPrivateFlag( Impl::PRIVATE_FLAG_LAYOUT_REQUIRED );
 184   }
 185
 186   mImpl->ClearPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
 187   mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_IS_LAID_OUT );
 188 }
 189
 190 LayoutLength LayoutItem::GetMinimumWidth() const
 191 {
 192   return mImpl->mMinimumSize.GetWidth();
 193 }
 194
 195 LayoutLength LayoutItem::GetMinimumHeight() const
 196 {
 197   return mImpl->mMinimumSize.GetHeight();
 198 }
 199
 200 void LayoutItem::SetMinimumWidth( LayoutLength minimumWidth )
 201 {
 202   mImpl->mMinimumSize.SetWidth( minimumWidth );
 203   RequestLayout();
 204 }
 205
 206 void LayoutItem::SetMinimumHeight( LayoutLength minimumHeight )
 207 {
 208   mImpl->mMinimumSize.SetHeight( minimumHeight );
 209   RequestLayout();
 210 }
 211
 212 Extents LayoutItem::GetPadding() const
 213 {
 214   Toolkit::Control control = Toolkit::Control::DownCast( mImpl->mOwner );
 215   if( control )
 216   {
 217     Extents padding = control.GetProperty<Extents>( Toolkit::Control::Property::PADDING );
 218
 219     DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutBase::Padding for %s : (%d,%d,%d,%d) \n",
 220                    control.GetName().c_str(),
 221                    padding.start, padding.end, padding.top, padding.bottom
 222                  );
 223     return padding;
 224   }
 225   else
 226   {
 227     return Extents();
 228   }
 229 }
 230
 231 Extents LayoutItem::GetMargin() const
 232 {
 233   Toolkit::Control control = Toolkit::Control::DownCast( mImpl->mOwner );
 234   if ( control )
 235   {
 236     return control.GetProperty<Extents>( Toolkit::Control::Property::MARGIN );
 237   }
 238   else
 239   {
 240     return Extents();
 241   }
 242 }
 243
 244 LayoutLength LayoutItem::GetDefaultSize( LayoutLength size, MeasureSpec measureSpec )
 245 {
 246   LayoutLength result = size;
 247   auto specMode = measureSpec.GetMode();
 248   auto specSize = measureSpec.GetSize();
 249
 250   switch (specMode)
 251   {
 252     case MeasureSpec::Mode::UNSPECIFIED:
 253     {
 254       result = size;
 255       break;
 256     }
 257     case MeasureSpec::Mode::AT_MOST:
 258     {
 259       LayoutLength tmp = specSize;
 260       if( size < tmp )
 261       {
 262         result = size;
 263       }
 264       else
 265       {
 266         result = specSize;
 267       }
 268       break;
 269     }
 270     case MeasureSpec::Mode::EXACTLY:
 271     {
 272       result = specSize;
 273       break;
 274     }
 275   }
 276   return result;
 277 }
 278
 279 void LayoutItem::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec)
 280 {
 281   SetMeasuredDimensions( GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec ),
 282                          GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec ) );
 283 }
 284
 285 void LayoutItem::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
 286 {
 287 }
 288
 289 void LayoutItem::SetParent( LayoutParent* parent )
 290 {
 291   mImpl->mLayoutParent = parent;
 292 }
 293
 294 LayoutParent* LayoutItem::GetParent()
 295 {
 296   return mImpl->mLayoutParent;
 297 }
 298
 299 void LayoutItem::RequestLayout()
 300 {
 301   Toolkit::Control control = Toolkit::Control::DownCast( mImpl->mOwner );
 302   if ( control )
 303   {
 304     DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutItem::RequestLayout %s\n", control.GetName().c_str());
 305   }
 306   // @todo Enforce failure if called in Measure/Layout passes.
 307   mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
 308   Toolkit::LayoutController layoutController = Toolkit::LayoutController::Get();
 309   layoutController.RequestLayout( Toolkit::LayoutItem(this) );
 310 }
 311
 312 bool LayoutItem::IsLayoutRequested() const
 313 {
 314   return mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
 315 }
 316
 317 void LayoutItem::SetLayoutRequested()
 318 {
 319   return mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
 320 }
 321
 322 void LayoutItem::SetMeasuredDimensions( MeasuredSize measuredWidth, MeasuredSize measuredHeight )
 323 {
 324   DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutBase::SetMeasuredDimensions width(%d) height(%d) \n",
 325                                                  MeasureSpec::IntType( measuredWidth.GetSize() ),
 326                                                  MeasureSpec::IntType( measuredHeight.GetSize() )
 327                );
 328
 329   mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_MEASURED_DIMENSION_SET );
 330   mImpl->mMeasuredWidth = measuredWidth;
 331   mImpl->mMeasuredHeight = measuredHeight;
 332 }
 333
 334 LayoutLength LayoutItem::GetMeasuredWidth() const
 335 {
 336   // Get the size portion of the measured width
 337   return  mImpl->mMeasuredWidth.GetSize();
 338 }
 339
 340 LayoutLength LayoutItem::GetMeasuredHeight() const
 341 {
 342   return  mImpl->mMeasuredHeight.GetSize();
 343 }
 344
 345 MeasuredSize LayoutItem::GetMeasuredWidthAndState() const
 346 {
 347   return mImpl->mMeasuredWidth;
 348 }
 349
 350 MeasuredSize LayoutItem::GetMeasuredHeightAndState() const
 351 {
 352   return mImpl->mMeasuredHeight;
 353 }
 354
 355 LayoutLength LayoutItem::GetSuggestedMinimumWidth() const
 356 {
 357   auto owner = GetOwner();
 358   auto actor = Actor::DownCast(owner);
 359   auto naturalSize = actor ? actor.GetNaturalSize() : Vector3::ZERO;
 360
 361   return std::max( mImpl->mMinimumSize.GetWidth(), LayoutLength::IntType( naturalSize.width ) );
 362 }
 363
 364 LayoutLength LayoutItem::GetSuggestedMinimumHeight() const
 365 {
 366   auto owner = GetOwner();
 367   auto actor = Actor::DownCast(owner);
 368   auto naturalSize = actor ? actor.GetNaturalSize() : Vector3::ZERO;
 369
 370   return std::max( mImpl->mMinimumSize.GetHeight(), LayoutLength::IntType(naturalSize.height) );
 371 }
 372
 373 MeasuredSize LayoutItem::ResolveSizeAndState( LayoutLength size, MeasureSpec measureSpec, MeasuredSize::State childMeasuredState )
 374 {
 375   auto specMode = measureSpec.GetMode();
 376   LayoutLength specSize = measureSpec.GetSize();
 377   MeasuredSize result;
 378
 379   switch( specMode )
 380   {
 381     case MeasureSpec::Mode::AT_MOST:
 382     {
 383       if (specSize < size)
 384       {
 385         result = MeasuredSize( specSize, MeasuredSize::MEASURED_SIZE_TOO_SMALL );
 386       }
 387       else
 388       {
 389         result.SetSize( size );
 390       }
 391       break;
 392     }
 393
 394     case MeasureSpec::Mode::EXACTLY:
 395     {
 396       result.SetSize( specSize );
 397       break;
 398     }
 399
 400     case MeasureSpec::Mode::UNSPECIFIED:
 401     default:
 402     {
 403       result.SetSize( size );
 404       break;
 405     }
 406   }
 407
 408   result.SetState( childMeasuredState );
 409   return result;
 410 }
 411
 412
 413 bool LayoutItem::SetFrame( LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
 414 {
 415   bool changed = false;
 416
 417   DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutItem::SetFrame enter(%d, %d, %d, %d)\n", left.mValue, top.mValue, right.mValue, bottom.mValue );
 418
 419   if( mImpl->mLeft != left || mImpl->mRight != right || mImpl->mTop != top || mImpl->mBottom != bottom )
 420   {
 421     changed = true;
 422
 423     auto oldWidth = mImpl->mRight - mImpl->mLeft;
 424     auto oldHeight = mImpl->mBottom - mImpl->mTop;
 425     auto newWidth = right - left;
 426     auto newHeight = bottom - top;
 427     bool sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
 428
 429     mImpl->mLeft = left;
 430     mImpl->mTop = top;
 431     mImpl->mRight = right;
 432     mImpl->mBottom = bottom;
 433
 434     mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_HAS_BOUNDS );
 435
 436
 437     // Reflect up to parent control
 438     auto owner = GetOwner();
 439     auto actor = Actor::DownCast(owner);
 440     if( actor )
 441     {
 442       if( mImpl->mAnimated )
 443       {
 444         auto animation = Animation::New( 0.5f );
 445         animation.AnimateTo( Property( actor, Actor::Property::POSITION ),
 446                              Vector3( float(left.mValue), float(top.mValue), 0.0f ) );
 447         animation.AnimateTo( Property( actor, Actor::Property::SIZE ),
 448                              Vector3( right-left, bottom-top, 0.0f ) );
 449         animation.FinishedSignal().Connect( mSlotDelegate, &LayoutItem::OnLayoutAnimationFinished );
 450         animation.Play();
 451       }
 452       else
 453       {
 454         // @todo Collate into list of Property & Property::Value pairs.
 455         actor.SetPosition( Vector3( float(left.mValue), float(top.mValue), 0.0f ) );
 456         actor.SetSize( Vector3( right-left, bottom-top, 0.0f ) );
 457       }
 458     }
 459
 460     if( sizeChanged )
 461     {
 462       SizeChange( LayoutSize( newWidth, newHeight ), LayoutSize( oldWidth, oldHeight ) );
 463     }
 464   }
 465
 466   DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutItem::SetFrame  exit(%d, %d, %d, %d)\n", left.mValue, top.mValue, right.mValue, bottom.mValue );
 467
 468   return changed;
 469 }
 470
 471 void LayoutItem::OnLayoutAnimationFinished( Animation& animation )
 472 {
 473   auto owner = GetOwner();
 474   auto actor = Actor::DownCast(owner);
 475   if( actor )
 476   {
 477     actor.SetSize( Vector3( mImpl->mRight-mImpl->mLeft, mImpl->mBottom-mImpl->mTop, 0.0f ) );
 478   }
 479 }
 480
 481 void LayoutItem::SizeChange( LayoutSize newSize, LayoutSize oldSize)
 482 {
 483   OnSizeChanged( newSize, oldSize );
 484 }
 485
 486
 487 void LayoutItem::OnSizeChanged( LayoutSize newSize, LayoutSize oldSize )
 488 {
 489 }
 490
 491 void LayoutItem::OnInitialize()
 492 {
 493 }
 494
 495
 496 } // namespace Internal
 497 } // namespace Toolkit
 498 } // namespace Dali