Add new layouting support for TextLabel and ImageView.
[platform/core/uifw/dali-toolkit.git] / 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