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