Fixed destructors (objects with a unique_ptr to an opaque structure
cannot use default destructor, instead, the destructor must be in a
translation unit where the opaque structure is available.
Change-Id: I105907af2ff970346c5418b1121919302a67e80a
27 files changed:
hbox1.SetName( "HBox1");
hbox2.SetName( "HBox2");
hbox1.SetName( "HBox1");
hbox2.SetName( "HBox2");
- hbox1.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- hbox1.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- hbox2.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- hbox2.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ hbox1.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ hbox1.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ hbox2.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ hbox2.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 20, 40 ) );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 20, 40 ) );
hbox1.SetName( "HBox1"); // Default spec is to wrap content
hbox2.SetName( "HBox2");
hbox1.SetName( "HBox1"); // Default spec is to wrap content
hbox2.SetName( "HBox2");
- hbox1.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
- hbox1.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
- hbox2.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
- hbox2.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ hbox1.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ hbox1.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ hbox2.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ hbox2.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 80, 40 ) );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 80, 40 ) );
- controls[6].SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ controls[6].SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
auto hbox3 = Control::New();
auto hboxLayout3 = HboxLayout::New();
DevelControl::SetLayout( hbox3, hboxLayout3 );
auto hbox3 = Control::New();
auto hboxLayout3 = HboxLayout::New();
DevelControl::SetLayout( hbox3, hboxLayout3 );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
stage.Add( vbox );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
stage.Add( vbox );
- controls[2].SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ controls[2].SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
// Ensure layouting happens
application.SendNotification();
// Ensure layouting happens
application.SendNotification();
vbox.SetName( "Vbox");
hbox.Add( vbox );
vbox.SetName( "Vbox");
hbox.Add( vbox );
- vbox.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
- vbox.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ vbox.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ vbox.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 40, 40 ) );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 40, 40 ) );
vbox.SetParentOrigin( ParentOrigin::CENTER );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
vbox.SetParentOrigin( ParentOrigin::CENTER );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
- controls[2].SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ controls[2].SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
// Ensure layouting happens
application.SendNotification();
// Ensure layouting happens
application.SendNotification();
vbox.SetName( "Vbox");
hbox.Add( vbox );
vbox.SetName( "Vbox");
hbox.Add( vbox );
- vbox.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
- vbox.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ vbox.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::WRAP_CONTENT );
+ vbox.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 40, 40 ) );
std::vector< Control > controls;
controls.push_back( CreateLeafControl( 40, 40 ) );
vbox.SetParentOrigin( ParentOrigin::CENTER );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
vbox.SetParentOrigin( ParentOrigin::CENTER );
vbox.SetAnchorPoint( AnchorPoint::CENTER );
- controls[2].SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
+ controls[2].SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, ChildLayoutData::MATCH_PARENT );
- DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
+ DALI_TEST_EQUALS( controls[2].GetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ), Property::Value( ChildLayoutData::MATCH_PARENT ), TEST_LOCATION );
// Ensure layouting happens
application.SendNotification();
// Ensure layouting happens
application.SendNotification();
Internal::Control::Impl::Get( control ).SetInputMethodContext( inputMethodContext );
}
Internal::Control::Impl::Get( control ).SetInputMethodContext( inputMethodContext );
}
-Toolkit::LayoutBase GetLayout( Control control )
+Toolkit::LayoutItem GetLayout( Control control )
{
const Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
{
const Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
const Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
- return Toolkit::LayoutBase( controlDataImpl.GetLayout().Get() );
+ return Toolkit::LayoutItem( controlDataImpl.GetLayout().Get() );
-Toolkit::LayoutBase GetLayout( Internal::Control& control )
+Toolkit::LayoutItem GetLayout( Internal::Control& control )
{
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
{
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
- return Toolkit::LayoutBase( controlDataImpl.GetLayout().Get() );
+ return Toolkit::LayoutItem( controlDataImpl.GetLayout().Get() );
-void SetLayout( Internal::Control& control, Toolkit::LayoutBase layout )
+void SetLayout( Internal::Control& control, Toolkit::LayoutItem layout )
{
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
controlDataImpl.SetLayout( GetImplementation( layout ) );
}
{
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( control );
controlDataImpl.SetLayout( GetImplementation( layout ) );
}
-void SetLayout( Control control, Toolkit::LayoutBase layout )
+void SetLayout( Control control, Toolkit::LayoutItem layout )
{
Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
{
Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( internalControl );
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
*
* @return A handle to the layout, or empty.
*/
*
* @return A handle to the layout, or empty.
*/
-DALI_TOOLKIT_API Toolkit::LayoutBase GetLayout( Internal::Control& control );
+DALI_TOOLKIT_API Toolkit::LayoutItem GetLayout( Internal::Control& control );
/*
* @brief Get the layout associated with a control, if any.
*
* @return A handle to the layout, or empty.
*/
/*
* @brief Get the layout associated with a control, if any.
*
* @return A handle to the layout, or empty.
*/
-DALI_TOOLKIT_API Toolkit::LayoutBase GetLayout( Control control );
+DALI_TOOLKIT_API Toolkit::LayoutItem GetLayout( Control control );
/**
* @brief Set the layout on this control.
/**
* @brief Set the layout on this control.
* @param[in] control The internal Control to set the layout on
* @param[in] layout Pointer to the layout
*/
* @param[in] control The internal Control to set the layout on
* @param[in] layout Pointer to the layout
*/
-DALI_TOOLKIT_API void SetLayout( Internal::Control& control, Toolkit::LayoutBase layout );
+DALI_TOOLKIT_API void SetLayout( Internal::Control& control, Toolkit::LayoutItem layout );
/**
* @brief Set the layout on a control.
/**
* @brief Set the layout on a control.
* @param[in] control The Control to set the layout on
* @param[in] layout Pointer to the layout
*/
* @param[in] control The Control to set the layout on
* @param[in] layout Pointer to the layout
*/
-DALI_TOOLKIT_API void SetLayout( Control control, Toolkit::LayoutBase layout );
+DALI_TOOLKIT_API void SetLayout( Control control, Toolkit::LayoutItem layout );
} // namespace DevelControl
} // namespace DevelControl
$(devel_api_src_dir)/image-loader/texture-manager.cpp \
$(devel_api_src_dir)/layouting/hbox-layout.cpp \
$(devel_api_src_dir)/layouting/vbox-layout.cpp \
$(devel_api_src_dir)/image-loader/texture-manager.cpp \
$(devel_api_src_dir)/layouting/hbox-layout.cpp \
$(devel_api_src_dir)/layouting/vbox-layout.cpp \
- $(devel_api_src_dir)/layouting/layout-base.cpp \
- $(devel_api_src_dir)/layouting/layout-base-impl.cpp \
+ $(devel_api_src_dir)/layouting/layout-item.cpp \
+ $(devel_api_src_dir)/layouting/layout-item-impl.cpp \
$(devel_api_src_dir)/layouting/layout-controller.cpp \
$(devel_api_src_dir)/layouting/layout-group.cpp \
$(devel_api_src_dir)/layouting/layout-group-impl.cpp \
$(devel_api_src_dir)/layouting/layout-controller.cpp \
$(devel_api_src_dir)/layouting/layout-group.cpp \
$(devel_api_src_dir)/layouting/layout-group-impl.cpp \
$(devel_api_src_dir)/layouting/child-layout-data.h \
$(devel_api_src_dir)/layouting/hbox-layout.h \
$(devel_api_src_dir)/layouting/vbox-layout.h \
$(devel_api_src_dir)/layouting/child-layout-data.h \
$(devel_api_src_dir)/layouting/hbox-layout.h \
$(devel_api_src_dir)/layouting/vbox-layout.h \
- $(devel_api_src_dir)/layouting/layout-base.h \
- $(devel_api_src_dir)/layouting/layout-base-impl.h \
+ $(devel_api_src_dir)/layouting/layout-item.h \
+ $(devel_api_src_dir)/layouting/layout-item-impl.h \
$(devel_api_src_dir)/layouting/layout-controller.h \
$(devel_api_src_dir)/layouting/layout-group.h \
$(devel_api_src_dir)/layouting/layout-group-impl.h \
$(devel_api_src_dir)/layouting/layout-length.h \
$(devel_api_src_dir)/layouting/layout-size.h \
$(devel_api_src_dir)/layouting/layout-controller.h \
$(devel_api_src_dir)/layouting/layout-group.h \
$(devel_api_src_dir)/layouting/layout-group-impl.h \
$(devel_api_src_dir)/layouting/layout-length.h \
$(devel_api_src_dir)/layouting/layout-size.h \
+ $(devel_api_src_dir)/layouting/measured-size.h \
+ $(devel_api_src_dir)/layouting/layout-parent-impl.h \
$(devel_api_src_dir)/layouting/measure-spec.h
devel_api_magnifier_header_files = \
$(devel_api_src_dir)/layouting/measure-spec.h
devel_api_magnifier_header_files = \
return layoutController;
}
return layoutController;
}
-void LayoutController::RequestLayout( LayoutBase layout )
+void LayoutController::RequestLayout( LayoutItem layout )
{
GetImpl(*this).RequestLayout( GetImplementation( layout ) );
}
{
GetImpl(*this).RequestLayout( GetImplementation( layout ) );
}
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/common/dali-common.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/common/dali-common.h>
#include <dali-toolkit/public-api/controls/control.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
#include <dali-toolkit/devel-api/layouting/layout-group.h>
namespace Dali
#include <dali-toolkit/devel-api/layouting/layout-group.h>
namespace Dali
* @brief Request for a particular layout (wrapping a control or a visual) to be measured and laid out.
* @param[in] layout The layout to measure & relayout.
*/
* @brief Request for a particular layout (wrapping a control or a visual) to be measured and laid out.
* @param[in] layout The layout to measure & relayout.
*/
- void RequestLayout( LayoutBase layout );
+ void RequestLayout( LayoutItem layout );
public:
/// @cond internal
public:
/// @cond internal
LayoutGroup::~LayoutGroup()
{
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.
-Toolkit::LayoutGroup::LayoutId LayoutGroup::Add( LayoutBase& child )
+Toolkit::LayoutGroup::LayoutId LayoutGroup::Add( LayoutItem& child )
{
LayoutParent* oldParent = child.GetParent();
if( oldParent )
{
LayoutParent* oldParent = child.GetParent();
if( oldParent )
auto owner = child.GetOwner();
auto owner = child.GetOwner();
- // If the owner does not have any LayoutBase child properties, add them
- if( ! DevelHandle::DoesCustomPropertyExist( owner, Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION ) )
+ // If the owner does not have any LayoutItem child properties, add them
+ if( ! DevelHandle::DoesCustomPropertyExist( owner, Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ) )
- // Set default properties for LayoutGroup and LayoutBase.
+ // Set default properties for LayoutGroup and LayoutItem.
// Deriving classes can override OnChildAdd() to add their own default properties
GenerateDefaultChildPropertyValues( owner );
}
// Deriving classes can override OnChildAdd() to add their own default properties
GenerateDefaultChildPropertyValues( owner );
}
-void LayoutGroup::Remove( LayoutBase& child )
+void LayoutGroup::Remove( LayoutItem& child )
{
for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
{
{
for( auto iter = mImpl->mChildren.begin() ; iter != mImpl->mChildren.end() ; ++iter )
{
return mImpl->mChildren.size();
}
return mImpl->mChildren.size();
}
-LayoutBasePtr LayoutGroup::GetChildAt( unsigned int index ) const
+LayoutItemPtr LayoutGroup::GetChildAt( unsigned int index ) const
{
DALI_ASSERT_ALWAYS( index < mImpl->mChildren.size() );
return mImpl->mChildren[ index ].child;
}
{
DALI_ASSERT_ALWAYS( index < mImpl->mChildren.size() );
return mImpl->mChildren[ index ].child;
}
-LayoutBasePtr LayoutGroup::GetChild( Toolkit::LayoutGroup::LayoutId childId ) const
+LayoutItemPtr LayoutGroup::GetChild( Toolkit::LayoutGroup::LayoutId childId ) const
{
for( auto&& childLayout : mImpl->mChildren )
{
{
for( auto&& childLayout : mImpl->mChildren )
{
-Toolkit::LayoutGroup::LayoutId LayoutGroup::GetChildId( LayoutBase& child ) const
+Toolkit::LayoutGroup::LayoutId LayoutGroup::GetChildId( LayoutItem& child ) const
{
for( auto&& childLayout : mImpl->mChildren )
{
{
for( auto&& childLayout : mImpl->mChildren )
{
return Toolkit::LayoutGroup::UNKNOWN_ID;
}
return Toolkit::LayoutGroup::UNKNOWN_ID;
}
-void LayoutGroup::OnChildAdd( LayoutBase& child )
+void LayoutGroup::OnChildAdd( LayoutItem& child )
-void LayoutGroup::OnChildRemove( LayoutBase& child )
+void LayoutGroup::OnChildRemove( LayoutItem& child )
void LayoutGroup::GenerateDefaultChildPropertyValues( Handle child )
{
void LayoutGroup::GenerateDefaultChildPropertyValues( Handle child )
{
- child.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION,
+ child.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION,
Toolkit::ChildLayoutData::WRAP_CONTENT );
Toolkit::ChildLayoutData::WRAP_CONTENT );
- child.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION,
+ child.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION,
Toolkit::ChildLayoutData::WRAP_CONTENT );
child.SetProperty( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION, Extents() );
}
Toolkit::ChildLayoutData::WRAP_CONTENT );
child.SetProperty( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION, Extents() );
}
-void LayoutGroup::MeasureChild( LayoutBasePtr child,
+void LayoutGroup::MeasureChild( LayoutItemPtr child,
MeasureSpec parentWidthMeasureSpec,
MeasureSpec parentHeightMeasureSpec )
{
auto childOwner = child->GetOwner();
MeasureSpec parentWidthMeasureSpec,
MeasureSpec parentHeightMeasureSpec )
{
auto childOwner = child->GetOwner();
- auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
- auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+ auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
auto padding = GetPadding();
auto padding = GetPadding();
child->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
}
child->Measure( childWidthMeasureSpec, childHeightMeasureSpec );
}
-void LayoutGroup::MeasureChildWithMargins( LayoutBasePtr child,
+void LayoutGroup::MeasureChildWithMargins( LayoutItemPtr child,
MeasureSpec parentWidthMeasureSpec, LayoutLength widthUsed,
MeasureSpec parentHeightMeasureSpec, LayoutLength heightUsed)
{
auto childOwner = child->GetOwner();
MeasureSpec parentWidthMeasureSpec, LayoutLength widthUsed,
MeasureSpec parentHeightMeasureSpec, LayoutLength heightUsed)
{
auto childOwner = child->GetOwner();
- auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
- auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+ auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
auto desiredMargin = childOwner.GetProperty<Extents>( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION );
auto padding = GetPadding();
auto desiredMargin = childOwner.GetProperty<Extents>( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION );
auto padding = GetPadding();
if (childDimension == Toolkit::ChildLayoutData::MATCH_PARENT)
{
// Child wants to be our size... find out how big it should be
if (childDimension == Toolkit::ChildLayoutData::MATCH_PARENT)
{
// Child wants to be our size... find out how big it should be
- resultSize = LayoutBase::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
+ resultSize = LayoutItem::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
resultMode = MeasureSpec::Mode::UNSPECIFIED;
}
else if (childDimension == Toolkit::ChildLayoutData::WRAP_CONTENT)
{
// Child wants to determine its own size.... find out how big
// it should be
resultMode = MeasureSpec::Mode::UNSPECIFIED;
}
else if (childDimension == Toolkit::ChildLayoutData::WRAP_CONTENT)
{
// Child wants to determine its own size.... find out how big
// it should be
- resultSize = LayoutBase::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
+ resultSize = LayoutItem::Impl::sUseZeroUnspecifiedMeasureSpec ? LayoutLength(0) : size;
resultMode = MeasureSpec::Mode::UNSPECIFIED;
}
else
resultMode = MeasureSpec::Mode::UNSPECIFIED;
}
else
void LayoutGroup::ChildAddedToOwner( Actor child )
{
void LayoutGroup::ChildAddedToOwner( Actor child )
{
- LayoutBasePtr childLayout;
+ LayoutItemPtr childLayout;
Toolkit::Control control = Toolkit::Control::DownCast( child );
if( control ) // Can only support adding Controls, not Actors to layout
Toolkit::Control control = Toolkit::Control::DownCast( child );
if( control ) // Can only support adding Controls, not Actors to layout
- // If the child doesn't already have a layout, then create a LayoutBase for it.
- childLayout = LayoutBase::New( control );
+ // 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?
auto desiredSize = control.GetNaturalSize();
childControlDataImpl.SetLayout( *childLayout.Get() );
// HBoxLayout will apply default layout data for this object
childLayout->SetAnimateLayout( IsLayoutAnimated() ); // @todo this essentially forces animation inheritance. Bad?
auto desiredSize = control.GetNaturalSize();
childControlDataImpl.SetLayout( *childLayout.Get() );
// HBoxLayout will apply default layout data for this object
- child.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, LayoutLength::IntType( desiredSize.width ) );
- child.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, LayoutLength::IntType( desiredSize.height ) );
+ child.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, LayoutLength::IntType( desiredSize.width ) );
+ child.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, LayoutLength::IntType( desiredSize.height ) );
child.SetProperty( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION, Extents() );
}
child.SetProperty( Toolkit::LayoutGroup::ChildProperty::MARGIN_SPECIFICATION, Extents() );
}
#include <dali/public-api/signals/connection-tracker.h>
#include <dali-toolkit/devel-api/layouting/child-layout-data.h>
#include <dali-toolkit/devel-api/layouting/layout-group.h>
#include <dali/public-api/signals/connection-tracker.h>
#include <dali-toolkit/devel-api/layouting/child-layout-data.h>
#include <dali-toolkit/devel-api/layouting/layout-group.h>
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
/**
* LayoutGroup is an abstract class that provides child layout management and basic measuring and layouting.
*
/**
* LayoutGroup is an abstract class that provides child layout management and basic measuring and layouting.
*
- * Deriving classes should override LayoutBase::DoInitialize for second stage initialization,
+ * Deriving classes should override LayoutItem::DoInitialize for second stage initialization,
* LayoutGroup::DoRegisterChildProperties to register child property types with the owner,
* LayoutGroup::OnChildAdd to apply default child property values to the child.
* Deriving classes may override LayoutGroup::OnChildRemove.
* LayoutGroup::DoRegisterChildProperties to register child property types with the owner,
* LayoutGroup::OnChildAdd to apply default child property values to the child.
* Deriving classes may override LayoutGroup::OnChildRemove.
* Deriving classes must also override OnMeasure and OnLayout as follows:
*
* OnMeasure should measure each child using LayoutGroup::MeasureChildWithMargins or LayoutGroup::MeasureChild.
* Deriving classes must also override OnMeasure and OnLayout as follows:
*
* OnMeasure should measure each child using LayoutGroup::MeasureChildWithMargins or LayoutGroup::MeasureChild.
- * We recommend calling LayoutBase::ResolveSizeAndState() to resolve measure specs.
+ * We recommend calling LayoutItem::ResolveSizeAndState() to resolve measure specs.
* If some children don't fit, then they can be measured again with different MeasureSpecs as required.
*
* After measurement, the derived class must also call SetMeasuredDimensions to set it's own requested size.
* If some children don't fit, then they can be measured again with different MeasureSpecs as required.
*
* After measurement, the derived class must also call SetMeasuredDimensions to set it's own requested size.
* OnLayout should use it's own layout parameters and the measured children's size to determine the children's
* position and size; it should then call Layout() on the child layout to layout the child and it's hierarchy.
*/
* OnLayout should use it's own layout parameters and the measured children's size to determine the children's
* position and size; it should then call Layout() on the child layout to layout the child and it's hierarchy.
*/
-class DALI_IMPORT_API LayoutGroup : public LayoutBase,
+class DALI_IMPORT_API LayoutGroup : public LayoutItem,
public ConnectionTracker
{
public:
public ConnectionTracker
{
public:
* @param[in] layoutChild The child to add
* @return The layout id of this child.
*/
* @param[in] layoutChild The child to add
* @return The layout id of this child.
*/
- Toolkit::LayoutGroup::LayoutId Add( LayoutBase& layoutChild );
+ Toolkit::LayoutGroup::LayoutId Add( LayoutItem& layoutChild );
/**
* @brief Remove a layout child from this group.
/**
* @brief Remove a layout child from this group.
* @brief Remove a layout child from this group
* @param[in] child The layout child
*/
* @brief Remove a layout child from this group
* @param[in] child The layout child
*/
- void Remove( LayoutBase& child );
+ void Remove( LayoutItem& child );
/**
* @brief Remove all layout children.
/**
* @brief Remove all layout children.
/**
* Get the child layout at the given index
*/
/**
* Get the child layout at the given index
*/
- LayoutBasePtr GetChildAt( unsigned int childIndex ) const;
+ LayoutItemPtr GetChildAt( unsigned int childIndex ) const;
/**
* Get the child layout id of the given child
*/
/**
* Get the child layout id of the given child
*/
- Toolkit::LayoutGroup::LayoutId GetChildId( LayoutBase& child ) const;
+ Toolkit::LayoutGroup::LayoutId GetChildId( LayoutItem& child ) const;
/**
* @brief Get the layout child with the given layout id.
/**
* @brief Get the layout child with the given layout id.
* @param[in] childId the layout id of the child within this group
* @return A pointer to the child layout
*/
* @param[in] childId the layout id of the child within this group
* @return A pointer to the child layout
*/
- LayoutBasePtr GetChild( Toolkit::LayoutGroup::LayoutId childId ) const;
+ LayoutItemPtr GetChild( Toolkit::LayoutGroup::LayoutId childId ) const;
- LayoutBasePtr GetChild( T childId ) = delete; // Prevent implicit casting of int/uint to LayoutId
+ LayoutItemPtr GetChild( T childId ) = delete; // Prevent implicit casting of int/uint to LayoutId
/**
* Callback when child is added to container.
* Derived classes can use this to set their own child properties on the child layout's owner.
*/
/**
* Callback when child is added to container.
* Derived classes can use this to set their own child properties on the child layout's owner.
*/
- virtual void OnChildAdd( LayoutBase& child );
+ virtual void OnChildAdd( LayoutItem& child );
/**
* Callback when child is removed from container.
*/
/**
* Callback when child is removed from container.
*/
- virtual void OnChildRemove( LayoutBase& child );
+ virtual void OnChildRemove( LayoutItem& child );
/**
* @brief Calculate the right measure spec for this child.
/**
* @brief Calculate the right measure spec for this child.
* @param parentWidthMeasureSpec The width requirements for this view
* @param parentHeightMeasureSpec The height requirements for this view
*/
* @param parentWidthMeasureSpec The width requirements for this view
* @param parentHeightMeasureSpec The height requirements for this view
*/
- virtual void MeasureChild( LayoutBasePtr child, MeasureSpec parentWidthMeasureSpec, MeasureSpec parentHeightMeasureSpec );
+ virtual void MeasureChild( LayoutItemPtr child, MeasureSpec parentWidthMeasureSpec, MeasureSpec parentHeightMeasureSpec );
/**
* Ask one of the children of this view to measure itself, taking into
/**
* Ask one of the children of this view to measure itself, taking into
* @param heightUsed Extra space that has been used up by the parent
* vertically (possibly by other children of the parent)
*/
* @param heightUsed Extra space that has been used up by the parent
* vertically (possibly by other children of the parent)
*/
- virtual void MeasureChildWithMargins( LayoutBasePtr child,
+ virtual void MeasureChildWithMargins( LayoutItemPtr child,
MeasureSpec parentWidthMeasureSpec,
LayoutLength widthUsed,
MeasureSpec parentHeightMeasureSpec,
MeasureSpec parentWidthMeasureSpec,
LayoutLength widthUsed,
MeasureSpec parentHeightMeasureSpec,
void OnInitialize() override final;
/**
void OnInitialize() override final;
/**
- * @copydoc LayoutBase::OnRegisterChildProperties()
+ * @copydoc LayoutItem::OnRegisterChildProperties()
*/
void OnRegisterChildProperties( const std::string& containerType ) override final;
/**
*/
void OnRegisterChildProperties( const std::string& containerType ) override final;
/**
- * @copydoc LayoutBase::OnUnparent
+ * @copydoc LayoutItem::OnUnparent
*/
void OnUnparent() override final;
*/
void OnUnparent() override final;
{
LayoutGroup::LayoutGroup()
{
LayoutGroup::LayoutGroup()
-LayoutGroup::LayoutId LayoutGroup::Add( LayoutBase& child )
+LayoutGroup::LayoutId LayoutGroup::Add( LayoutItem& child )
{
return GetImplementation( *this ).Add( GetImplementation(child) );
}
{
return GetImplementation( *this ).Add( GetImplementation(child) );
}
GetImplementation( *this ).Remove( childId );
}
GetImplementation( *this ).Remove( childId );
}
-void LayoutGroup::Remove( LayoutBase& child )
+void LayoutGroup::Remove( LayoutItem& child )
{
GetImplementation( *this ).Remove( GetImplementation(child) );
}
{
GetImplementation( *this ).Remove( GetImplementation(child) );
}
-LayoutBase LayoutGroup::GetChild( LayoutGroup::LayoutId childId ) const
+LayoutItem LayoutGroup::GetChild( LayoutGroup::LayoutId childId ) const
- Internal::LayoutBasePtr child = GetImplementation( *this ).GetChild( childId );
- return LayoutBase( child.Get() );
+ Internal::LayoutItemPtr child = GetImplementation( *this ).GetChild( childId );
+ return LayoutItem( child.Get() );
-LayoutBase LayoutGroup::GetChildAt( unsigned int childId ) const
+LayoutItem LayoutGroup::GetChildAt( unsigned int childId ) const
- Internal::LayoutBasePtr child = GetImplementation( *this ).GetChildAt( childId );
- return LayoutBase( child.Get() );
+ Internal::LayoutItemPtr child = GetImplementation( *this ).GetChildAt( childId );
+ return LayoutItem( child.Get() );
}
unsigned int LayoutGroup::GetChildCount() const
}
unsigned int LayoutGroup::GetChildCount() const
}
LayoutGroup::LayoutGroup( Internal::LayoutGroup* layoutGroup )
}
LayoutGroup::LayoutGroup( Internal::LayoutGroup* layoutGroup )
-: LayoutBase( layoutGroup )
+: LayoutItem( layoutGroup )
#include <memory>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <memory>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/actors/actor-enumerations.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
#include <dali-toolkit/devel-api/layouting/measure-spec.h>
namespace Dali
#include <dali-toolkit/devel-api/layouting/measure-spec.h>
namespace Dali
- * A layout that has layout children. Implements LayoutBase.
+ * A layout that has layout children. Implements LayoutItem.
* It can both layout it's children, and be laid out by a parent container.
*
* A layout group automatically handles adding a Control container's children to itself,
* It can both layout it's children, and be laid out by a parent container.
*
* A layout group automatically handles adding a Control container's children to itself,
* To write a new layout, inherit from both LayoutGroup handle and Internal::LayoutGroup body.
*
*/
* To write a new layout, inherit from both LayoutGroup handle and Internal::LayoutGroup body.
*
*/
-class DALI_IMPORT_API LayoutGroup : public LayoutBase
+class DALI_IMPORT_API LayoutGroup : public LayoutItem
{
public:
using LayoutId = unsigned int;
{
public:
using LayoutId = unsigned int;
* @param[in] childLayout The layout to add.
* @return an Id of the child.
*/
* @param[in] childLayout The layout to add.
* @return an Id of the child.
*/
- LayoutId Add( LayoutBase& childLayout );
+ LayoutId Add( LayoutItem& childLayout );
/**
* @brief Add a child layout to the layout group
/**
* @brief Add a child layout to the layout group
*
* @param[in] childLayout The layout to remove.
*/
*
* @param[in] childLayout The layout to remove.
*/
- void Remove( LayoutBase& childLayout );
+ void Remove( LayoutItem& childLayout );
/**
* @brief Get the child at the given index.
*
* @param[in] index The index of the child.
*/
/**
* @brief Get the child at the given index.
*
* @param[in] index The index of the child.
*/
- LayoutBase GetChildAt( unsigned int index ) const;
+ LayoutItem GetChildAt( unsigned int index ) const;
/**
* @brief Get the count of the children of the layout
/**
* @brief Get the count of the children of the layout
* @param[in] childId The id of the child to get
* @return A handle to the child layout, or empty if not found
*/
* @param[in] childId The id of the child to get
* @return A handle to the child layout, or empty if not found
*/
- LayoutBase GetChild( LayoutId childId ) const ;
+ LayoutItem GetChild( LayoutId childId ) const ;
/**
* Delete template method to remove implicit casting to integer types.
*/
template <typename T>
/**
* Delete template method to remove implicit casting to integer types.
*/
template <typename T>
- LayoutBase GetChild( T childId ) = delete;
+ LayoutItem GetChild( T childId ) = delete;
public:
/// @cond internal
public:
/// @cond internal
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali-toolkit/public-api/controls/control.h>
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
-#include <dali-toolkit/internal/layouting/layout-base-data-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
+#include <dali-toolkit/internal/layouting/layout-item-data-impl.h>
#if defined(DEBUG_ENABLED)
Debug::Filter* gLayoutFilter = Debug::Filter::New( Debug::Verbose, false, "LOG_LAYOUT" );
#if defined(DEBUG_ENABLED)
Debug::Filter* gLayoutFilter = Debug::Filter::New( Debug::Verbose, false, "LOG_LAYOUT" );
-LayoutBase::LayoutBase()
-: mImpl( new LayoutBase::Impl() ),
+LayoutItem::LayoutItem()
+: mImpl( new LayoutItem::Impl() ),
mSlotDelegate( this )
{
}
mSlotDelegate( this )
{
}
-LayoutBasePtr LayoutBase::New( Handle& owner )
+LayoutItem::~LayoutItem()
- LayoutBasePtr layoutPtr = new LayoutBase();
+ // 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.
+}
+
+LayoutItemPtr LayoutItem::New( Handle& owner )
+{
+ LayoutItemPtr layoutPtr = new LayoutItem();
-void LayoutBase::Initialize( Handle& owner, const std::string& containerType )
+void LayoutItem::Initialize( Handle& owner, const std::string& containerType )
{
mImpl->mOwner = &(owner.GetBaseObject());
RegisterChildProperties( containerType );
{
mImpl->mOwner = &(owner.GetBaseObject());
RegisterChildProperties( containerType );
-Handle LayoutBase::GetOwner() const
+Handle LayoutItem::GetOwner() const
{
return Handle::DownCast(BaseHandle(mImpl->mOwner));
}
{
return Handle::DownCast(BaseHandle(mImpl->mOwner));
}
-void LayoutBase::Unparent()
+void LayoutItem::Unparent()
{
// Enable directly derived types to first remove children
OnUnparent();
{
// Enable directly derived types to first remove children
OnUnparent();
-void LayoutBase::SetAnimateLayout( bool animateLayout )
+void LayoutItem::SetAnimateLayout( bool animateLayout )
{
mImpl->mAnimated = animateLayout;
}
{
mImpl->mAnimated = animateLayout;
}
-bool LayoutBase::IsLayoutAnimated() const
+bool LayoutItem::IsLayoutAnimated() const
{
return mImpl->mAnimated;
}
{
return mImpl->mAnimated;
}
-void LayoutBase::RegisterChildProperties( const std::string& containerType )
+void LayoutItem::RegisterChildProperties( const std::string& containerType )
{
// Call on derived types
auto typeInfo = TypeRegistry::Get().GetTypeInfo( containerType );
{
// Call on derived types
auto typeInfo = TypeRegistry::Get().GetTypeInfo( containerType );
Property::IndexContainer indices;
typeInfo.GetChildPropertyIndices( indices );
Property::IndexContainer indices;
typeInfo.GetChildPropertyIndices( indices );
- if( std::find( indices.Begin(), indices.End(), Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION ) ==
+ if( std::find( indices.Begin(), indices.End(), Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION ) ==
indices.End() )
{
ChildPropertyRegistration( typeInfo.GetName(), WIDTH_SPECIFICATION_NAME,
indices.End() )
{
ChildPropertyRegistration( typeInfo.GetName(), WIDTH_SPECIFICATION_NAME,
- Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, Property::INTEGER );
+ Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, Property::INTEGER );
ChildPropertyRegistration( typeInfo.GetName(), HEIGHT_SPECIFICATION_NAME,
ChildPropertyRegistration( typeInfo.GetName(), HEIGHT_SPECIFICATION_NAME,
- Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, Property::INTEGER );
+ Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, Property::INTEGER );
}
OnRegisterChildProperties( containerType );
}
}
}
OnRegisterChildProperties( containerType );
}
}
-void LayoutBase::OnRegisterChildProperties( const std::string& containerType )
+void LayoutItem::OnRegisterChildProperties( const std::string& containerType )
-void LayoutBase::Measure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
+void LayoutItem::Measure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec )
{
const bool forceLayout = mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
{
const bool forceLayout = mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
//mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 | (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}
//mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 | (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}
-void LayoutBase::Layout( LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b )
+void LayoutItem::Layout( LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b )
{
if( mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_MEASURE_NEEDED_BEFORE_LAYOUT ) )
{
{
if( mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_MEASURE_NEEDED_BEFORE_LAYOUT ) )
{
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_IS_LAID_OUT );
}
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_IS_LAID_OUT );
}
-LayoutLength LayoutBase::GetMinimumWidth() const
+LayoutLength LayoutItem::GetMinimumWidth() const
{
return mImpl->mMinimumSize.GetWidth();
}
{
return mImpl->mMinimumSize.GetWidth();
}
-LayoutLength LayoutBase::GetMinimumHeight() const
+LayoutLength LayoutItem::GetMinimumHeight() const
{
return mImpl->mMinimumSize.GetHeight();
}
{
return mImpl->mMinimumSize.GetHeight();
}
-void LayoutBase::SetMinimumWidth( LayoutLength minimumWidth )
+void LayoutItem::SetMinimumWidth( LayoutLength minimumWidth )
{
mImpl->mMinimumSize.SetWidth( minimumWidth );
RequestLayout();
}
{
mImpl->mMinimumSize.SetWidth( minimumWidth );
RequestLayout();
}
-void LayoutBase::SetMinimumHeight( LayoutLength minimumHeight )
+void LayoutItem::SetMinimumHeight( LayoutLength minimumHeight )
{
mImpl->mMinimumSize.SetHeight( minimumHeight );
RequestLayout();
}
{
mImpl->mMinimumSize.SetHeight( minimumHeight );
RequestLayout();
}
-Extents LayoutBase::GetPadding() const
+Extents LayoutItem::GetPadding() const
{
return mImpl->mPadding;
}
{
return mImpl->mPadding;
}
-LayoutLength LayoutBase::GetDefaultSize( LayoutLength size, MeasureSpec measureSpec )
+LayoutLength LayoutItem::GetDefaultSize( LayoutLength size, MeasureSpec measureSpec )
{
LayoutLength result = size;
auto specMode = measureSpec.GetMode();
{
LayoutLength result = size;
auto specMode = measureSpec.GetMode();
-void LayoutBase::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec)
+void LayoutItem::OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec)
{
SetMeasuredDimensions( GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec ),
GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec ) );
}
{
SetMeasuredDimensions( GetDefaultSize( GetSuggestedMinimumWidth(), widthMeasureSpec ),
GetDefaultSize( GetSuggestedMinimumHeight(), heightMeasureSpec ) );
}
-void LayoutBase::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
+void LayoutItem::OnLayout( bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
-LayoutParent* LayoutBase::GetParent()
+LayoutParent* LayoutItem::GetParent()
{
return mImpl->mLayoutParent;
}
{
return mImpl->mLayoutParent;
}
-void LayoutBase::RequestLayout()
+void LayoutItem::RequestLayout()
{
// @todo Enforce failure if called in Measure/Layout passes.
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
Toolkit::LayoutController layoutController = Toolkit::LayoutController::Get();
{
// @todo Enforce failure if called in Measure/Layout passes.
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
Toolkit::LayoutController layoutController = Toolkit::LayoutController::Get();
- layoutController.RequestLayout( Toolkit::LayoutBase(this) );
+ layoutController.RequestLayout( Toolkit::LayoutItem(this) );
-bool LayoutBase::IsLayoutRequested() const
+bool LayoutItem::IsLayoutRequested() const
{
return mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
}
{
return mImpl->GetPrivateFlag( Impl::PRIVATE_FLAG_FORCE_LAYOUT );
}
-void LayoutBase::SetMeasuredDimensions( MeasuredSize measuredWidth, MeasuredSize measuredHeight )
+void LayoutItem::SetMeasuredDimensions( MeasuredSize measuredWidth, MeasuredSize measuredHeight )
{
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_MEASURED_DIMENSION_SET );
mImpl->mMeasuredWidth = measuredWidth;
mImpl->mMeasuredHeight = measuredHeight;
}
{
mImpl->SetPrivateFlag( Impl::PRIVATE_FLAG_MEASURED_DIMENSION_SET );
mImpl->mMeasuredWidth = measuredWidth;
mImpl->mMeasuredHeight = measuredHeight;
}
-LayoutLength LayoutBase::GetMeasuredWidth() const
+LayoutLength LayoutItem::GetMeasuredWidth() const
{
// Get the size portion of the measured width
return mImpl->mMeasuredWidth.GetSize();
}
{
// Get the size portion of the measured width
return mImpl->mMeasuredWidth.GetSize();
}
-LayoutLength LayoutBase::GetMeasuredHeight() const
+LayoutLength LayoutItem::GetMeasuredHeight() const
{
return mImpl->mMeasuredHeight.GetSize();
}
{
return mImpl->mMeasuredHeight.GetSize();
}
-MeasuredSize LayoutBase::GetMeasuredWidthAndState() const
+MeasuredSize LayoutItem::GetMeasuredWidthAndState() const
{
return mImpl->mMeasuredWidth;
}
{
return mImpl->mMeasuredWidth;
}
-MeasuredSize LayoutBase::GetMeasuredHeightAndState() const
+MeasuredSize LayoutItem::GetMeasuredHeightAndState() const
{
return mImpl->mMeasuredHeight;
}
{
return mImpl->mMeasuredHeight;
}
-LayoutLength LayoutBase::GetSuggestedMinimumWidth() const
+LayoutLength LayoutItem::GetSuggestedMinimumWidth() const
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
return std::max( mImpl->mMinimumSize.GetWidth(), LayoutLength::IntType( naturalSize.width ) );
}
return std::max( mImpl->mMinimumSize.GetWidth(), LayoutLength::IntType( naturalSize.width ) );
}
-LayoutLength LayoutBase::GetSuggestedMinimumHeight() const
+LayoutLength LayoutItem::GetSuggestedMinimumHeight() const
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
return std::max( mImpl->mMinimumSize.GetHeight(), LayoutLength::IntType(naturalSize.height) );
}
return std::max( mImpl->mMinimumSize.GetHeight(), LayoutLength::IntType(naturalSize.height) );
}
-MeasuredSize LayoutBase::ResolveSizeAndState( LayoutLength size, MeasureSpec measureSpec, MeasuredSize::State childMeasuredState )
+MeasuredSize LayoutItem::ResolveSizeAndState( LayoutLength size, MeasureSpec measureSpec, MeasuredSize::State childMeasuredState )
{
auto specMode = measureSpec.GetMode();
LayoutLength specSize = measureSpec.GetSize();
{
auto specMode = measureSpec.GetMode();
LayoutLength specSize = measureSpec.GetSize();
-bool LayoutBase::SetFrame( LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
+bool LayoutItem::SetFrame( LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom )
- DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutBase::SetFrame(%d, %d, %d, %d)\n", left.mValue, top.mValue, right.mValue, bottom.mValue );
+ DALI_LOG_INFO( gLayoutFilter, Debug::Verbose, "LayoutItem::SetFrame(%d, %d, %d, %d)\n", left.mValue, top.mValue, right.mValue, bottom.mValue );
if( mImpl->mLeft != left || mImpl->mRight != right || mImpl->mTop != top || mImpl->mBottom != bottom )
{
if( mImpl->mLeft != left || mImpl->mRight != right || mImpl->mTop != top || mImpl->mBottom != bottom )
{
Vector3( float(left.mValue), float(top.mValue), 0.0f ) );
animation.AnimateTo( Property( actor, Actor::Property::SIZE ),
Vector3( right-left, bottom-top, 0.0f ) );
Vector3( float(left.mValue), float(top.mValue), 0.0f ) );
animation.AnimateTo( Property( actor, Actor::Property::SIZE ),
Vector3( right-left, bottom-top, 0.0f ) );
- animation.FinishedSignal().Connect( mSlotDelegate, &LayoutBase::OnLayoutAnimationFinished );
+ animation.FinishedSignal().Connect( mSlotDelegate, &LayoutItem::OnLayoutAnimationFinished );
-void LayoutBase::OnLayoutAnimationFinished( Animation& animation )
+void LayoutItem::OnLayoutAnimationFinished( Animation& animation )
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
{
auto owner = GetOwner();
auto actor = Actor::DownCast(owner);
-void LayoutBase::SizeChange( LayoutSize newSize, LayoutSize oldSize)
+void LayoutItem::SizeChange( LayoutSize newSize, LayoutSize oldSize)
{
OnSizeChanged( newSize, oldSize );
}
{
OnSizeChanged( newSize, oldSize );
}
-void LayoutBase::OnSizeChanged( LayoutSize newSize, LayoutSize oldSize )
+void LayoutItem::OnSizeChanged( LayoutSize newSize, LayoutSize oldSize )
-void LayoutBase::OnInitialize()
+void LayoutItem::OnInitialize()
-#ifndef DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_BASE_H
-#define DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_BASE_H
+#ifndef DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_ITEM_H
+#define DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_ITEM_H
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <dali-toolkit/devel-api/layouting/child-layout-data.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <dali-toolkit/devel-api/layouting/child-layout-data.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
#include <dali-toolkit/devel-api/layouting/layout-parent-impl.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
#include <dali-toolkit/devel-api/layouting/layout-size.h>
#include <dali-toolkit/devel-api/layouting/layout-parent-impl.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
#include <dali-toolkit/devel-api/layouting/layout-size.h>
-class LayoutBase;
-using LayoutBasePtr = IntrusivePtr<LayoutBase>;
+class LayoutItem;
+using LayoutItemPtr = IntrusivePtr<LayoutItem>;
/**
* Base class for layouts.
*/
/**
* Base class for layouts.
*/
-class DALI_IMPORT_API LayoutBase : public BaseObject,
+class DALI_IMPORT_API LayoutItem : public BaseObject,
public LayoutParent
{
public:
/**
* Constructor.
*/
public LayoutParent
{
public:
/**
* Constructor.
*/
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- ~LayoutBase() = default;
* @brief Construct
*
* @param[in] owner The owner (container view / child view / visual ) of this layout
* @brief Construct
*
* @param[in] owner The owner (container view / child view / visual ) of this layout
- * @return a new LayoutBase object
+ * @return a new LayoutItem object
- static LayoutBasePtr New( Handle& owner );
+ static LayoutItemPtr New( Handle& owner );
/**
* @brief Remove the default copy constructor
*/
/**
* @brief Remove the default copy constructor
*/
- LayoutBase(const LayoutBase& copy)=delete;
+ LayoutItem(const LayoutItem& copy)=delete;
/**
* @brief Remove the default assignment operator
*/
/**
* @brief Remove the default assignment operator
*/
- LayoutBase& operator=(const LayoutBase& rhs)=delete;
+ LayoutItem& operator=(const LayoutItem& rhs)=delete;
/**
* @brief Initialize the layout with it's owner and owner's type name
/**
* @brief Initialize the layout with it's owner and owner's type name
private:
std::unique_ptr<Impl> mImpl; ///< Implementation class holds all the data
private:
std::unique_ptr<Impl> mImpl; ///< Implementation class holds all the data
- SlotDelegate<LayoutBase> mSlotDelegate;
+ SlotDelegate<LayoutItem> mSlotDelegate;
};
} //namespace Internal
};
} //namespace Internal
-inline Internal::LayoutBase& GetImplementation( Dali::Toolkit::LayoutBase& handle )
+inline Internal::LayoutItem& GetImplementation( Dali::Toolkit::LayoutItem& handle )
- DALI_ASSERT_ALWAYS( handle && "LayoutBase handle is empty" );
+ DALI_ASSERT_ALWAYS( handle && "LayoutItem handle is empty" );
BaseObject& object = handle.GetBaseObject();
BaseObject& object = handle.GetBaseObject();
- return static_cast< Internal::LayoutBase& >( object );
+ return static_cast< Internal::LayoutItem& >( object );
-inline const Internal::LayoutBase& GetImplementation( const Dali::Toolkit::LayoutBase& handle )
+inline const Internal::LayoutItem& GetImplementation( const Dali::Toolkit::LayoutItem& handle )
- DALI_ASSERT_ALWAYS( handle && "LayoutBase handle is empty" );
+ DALI_ASSERT_ALWAYS( handle && "LayoutItem handle is empty" );
const BaseObject& object = handle.GetBaseObject();
const BaseObject& object = handle.GetBaseObject();
- return static_cast< const Internal::LayoutBase& >( object );
+ return static_cast< const Internal::LayoutItem& >( object );
}
} //namespace Toolkit
} //namespace Dali
}
} //namespace Toolkit
} //namespace Dali
-#endif // DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_BASE_H
+#endif // DALI_TOOLKIT_INTERNAL_LAYOUTING_LAYOUT_ITEM_H
* limitations under the License.
*/
* limitations under the License.
*/
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
namespace Dali
{
namespace Toolkit
{
namespace Dali
{
namespace Toolkit
{
-LayoutBase::LayoutBase()
+LayoutItem::LayoutItem()
-LayoutBase LayoutBase::New( Handle& handle )
+LayoutItem LayoutItem::New( Handle& handle )
- Internal::LayoutBasePtr layout = Internal::LayoutBase::New( handle );
- return LayoutBase( layout.Get() );
+ Internal::LayoutItemPtr layout = Internal::LayoutItem::New( handle );
+ return LayoutItem( layout.Get() );
-LayoutBase::LayoutBase( Internal::LayoutBase* layoutBase )
-: BaseHandle( layoutBase )
+LayoutItem::LayoutItem( Internal::LayoutItem* LayoutItem )
+: BaseHandle( LayoutItem )
-Handle LayoutBase::GetOwner() const
+Handle LayoutItem::GetOwner() const
{
return GetImplementation( *this ).GetOwner();
}
{
return GetImplementation( *this ).GetOwner();
}
-void LayoutBase::SetAnimateLayout( bool animateLayout )
+void LayoutItem::SetAnimateLayout( bool animateLayout )
{
GetImplementation( *this ).SetAnimateLayout( animateLayout );
}
{
GetImplementation( *this ).SetAnimateLayout( animateLayout );
}
-bool LayoutBase::IsLayoutAnimated() const
+bool LayoutItem::IsLayoutAnimated() const
{
return GetImplementation( *this ).IsLayoutAnimated();
}
{
return GetImplementation( *this ).IsLayoutAnimated();
}
-#ifndef DALI_TOOLKIT_LAYOUTING_LAYOUT_BASE_H
-#define DALI_TOOLKIT_LAYOUTING_LAYOUT_BASE_H
+#ifndef DALI_TOOLKIT_LAYOUTING_LAYOUT_ITEM_H
+#define DALI_TOOLKIT_LAYOUTING_LAYOUT_ITEM_H
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
}
using LayoutId = unsigned int;
}
using LayoutId = unsigned int;
* Base class for layouts. It is used to layout a control (or visual).
* It can be laid out by a LayoutGroup.
*/
* Base class for layouts. It is used to layout a control (or visual).
* It can be laid out by a LayoutGroup.
*/
-class DALI_IMPORT_API LayoutBase : public BaseHandle
+class DALI_IMPORT_API LayoutItem : public BaseHandle
- * @brief Default constructor which provides an uninitialized Dali::LayoutBase.
+ * @brief Default constructor which provides an uninitialized Dali::LayoutItem.
/**
* @brief Default destructor
*/
/**
* @brief Default destructor
*/
- * @brief Create an initialized LayoutBase
+ * @brief Create an initialized LayoutItem
*
* @param[in] handle A handle to the object that this layout for, e.g. a Control or a Visual::Base
* @warning This is an interim function, and will be deleted when all controls have layouts
* @todo Ensure that this warning is implemented
*/
*
* @param[in] handle A handle to the object that this layout for, e.g. a Control or a Visual::Base
* @warning This is an interim function, and will be deleted when all controls have layouts
* @todo Ensure that this warning is implemented
*/
- static LayoutBase New( Handle& handle );
+ static LayoutItem New( Handle& handle );
/**
* @brief Copy constructor
/**
* @brief Copy constructor
- * @param[in] copy The LayoutBase to copy.
+ * @param[in] copy The LayoutItem to copy.
- LayoutBase(const LayoutBase& copy) = default;
+ LayoutItem(const LayoutItem& copy) = default;
/**
* @brief Assignment operator
/**
* @brief Assignment operator
- * @param[in] rhs The LayoutBase to copy
+ * @param[in] rhs The LayoutItem to copy
- LayoutBase& operator=( const LayoutBase& rhs ) = default;
+ LayoutItem& operator=( const LayoutItem& rhs ) = default;
/**
* @brief Get a handle to the control or visual this layout represents.
/**
* @brief Get a handle to the control or visual this layout represents.
public:
/// @cond internal
/**
public:
/// @cond internal
/**
- * @brief This constructor is used by LayoutBase::New() methods.
+ * @brief This constructor is used by LayoutItem::New() methods.
*
* @param[in] actor A pointer to a newly allocated Dali resource
*/
*
* @param[in] actor A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL LayoutBase( Internal::LayoutBase* layoutBase );
+ explicit DALI_INTERNAL LayoutItem( Internal::LayoutItem* LayoutItem );
}//namespace Toolkit
}//namespace Dali
}//namespace Toolkit
}//namespace Dali
-#endif // DALI_TOOLKIT_LAYOUTING_LAYOUT_BASE_H
+#endif // DALI_TOOLKIT_LAYOUTING_LAYOUT_ITEM_H
-Toolkit::Internal::LayoutBasePtr Control::Impl::GetLayout() const
+Toolkit::Internal::LayoutItemPtr Control::Impl::GetLayout() const
-void Control::Impl::SetLayout( Toolkit::Internal::LayoutBase& layout )
+void Control::Impl::SetLayout( Toolkit::Internal::LayoutItem& layout )
#include <dali-toolkit/internal/visuals/visual-resource-observer.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali/devel-api/common/owner-container.h>
#include <dali-toolkit/internal/visuals/visual-resource-observer.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali/devel-api/common/owner-container.h>
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
#include <dali-toolkit/internal/controls/tooltip/tooltip.h>
#include <dali-toolkit/internal/builder/style.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
#include <dali-toolkit/internal/controls/tooltip/tooltip.h>
#include <dali-toolkit/internal/builder/style.h>
*
* @return A pointer to the layout, or NULL.
*/
*
* @return A pointer to the layout, or NULL.
*/
- Toolkit::Internal::LayoutBasePtr GetLayout() const;
+ Toolkit::Internal::LayoutItemPtr GetLayout() const;
/**
* @brief Set the layout on this control.
* @param[in] layout Pointer to the layout
*/
/**
* @brief Set the layout on this control.
* @param[in] layout Pointer to the layout
*/
- void SetLayout( Toolkit::Internal::LayoutBase& layout );
+ void SetLayout( Toolkit::Internal::LayoutItem& layout );
std::string mSubStateName;
// Layout
std::string mSubStateName;
// Layout
- Toolkit::Internal::LayoutBasePtr mLayout;
+ Toolkit::Internal::LayoutItemPtr mLayout;
int mLeftFocusableActorId; ///< Actor ID of Left focusable control.
int mRightFocusableActorId; ///< Actor ID of Right focusable control.
int mLeftFocusableActorId; ///< Actor ID of Left focusable control.
int mRightFocusableActorId; ///< Actor ID of Right focusable control.
$(toolkit_src_dir)/builder/replacement.cpp \
$(toolkit_src_dir)/layouting/hbox-layout-impl.cpp \
$(toolkit_src_dir)/layouting/vbox-layout-impl.cpp \
$(toolkit_src_dir)/builder/replacement.cpp \
$(toolkit_src_dir)/layouting/hbox-layout-impl.cpp \
$(toolkit_src_dir)/layouting/vbox-layout-impl.cpp \
- $(toolkit_src_dir)/layouting/layout-base-data-impl.cpp \
+ $(toolkit_src_dir)/layouting/layout-item-data-impl.cpp \
$(toolkit_src_dir)/layouting/layout-group-data-impl.cpp \
$(toolkit_src_dir)/layouting/layout-controller-debug.cpp \
$(toolkit_src_dir)/layouting/layout-controller-impl.cpp \
$(toolkit_src_dir)/layouting/layout-group-data-impl.cpp \
$(toolkit_src_dir)/layouting/layout-controller-debug.cpp \
$(toolkit_src_dir)/layouting/layout-controller-impl.cpp \
#include <dali/integration-api/debug.h>
#include <dali/public-api/common/extents.h>
#include <dali/public-api/actors/actor.h>
#include <dali/integration-api/debug.h>
#include <dali/public-api/common/extents.h>
#include <dali/public-api/actors/actor.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
-void HboxLayout::OnChildAdd( LayoutBase& child )
+void HboxLayout::OnChildAdd( LayoutItem& child )
{
auto owner = child.GetOwner();
owner.SetProperty( Toolkit::HboxLayout::ChildProperty::WEIGHT, 1.0f );
{
auto owner = child.GetOwner();
owner.SetProperty( Toolkit::HboxLayout::ChildProperty::WEIGHT, 1.0f );
if( childLayout )
{
auto childOwner = childLayout->GetOwner();
if( childLayout )
{
auto childOwner = childLayout->GetOwner();
- auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, heightMeasureSpec, 0 );
auto childWidth = childLayout->GetMeasuredWidth();
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, heightMeasureSpec, 0 );
auto childWidth = childLayout->GetMeasuredWidth();
auto uniformMeasureSpec = MeasureSpec( GetMeasuredHeight(), MeasureSpec::Mode::EXACTLY );
for (int i = 0; i < count; ++i)
{
auto uniformMeasureSpec = MeasureSpec( GetMeasuredHeight(), MeasureSpec::Mode::EXACTLY );
for (int i = 0; i < count; ++i)
{
- LayoutBasePtr childLayout = GetChildAt(i);
+ LayoutItemPtr childLayout = GetChildAt(i);
if( childLayout != nullptr )
{
auto childOwner = childLayout->GetOwner();
if( childLayout != nullptr )
{
auto childOwner = childLayout->GetOwner();
- auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
- auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+ auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
if( desiredHeight == Toolkit::ChildLayoutData::MATCH_PARENT )
{
// Temporarily force children to reuse their old measured width
int oldWidth = desiredWidth;
if( desiredHeight == Toolkit::ChildLayoutData::MATCH_PARENT )
{
// Temporarily force children to reuse their old measured width
int oldWidth = desiredWidth;
- childOwner.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, childLayout->GetMeasuredWidth().mValue );
+ childOwner.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, childLayout->GetMeasuredWidth().mValue );
// Remeasure with new dimensions
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, uniformMeasureSpec, 0);
// Remeasure with new dimensions
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, uniformMeasureSpec, 0);
- childOwner.SetProperty( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION, oldWidth );
+ childOwner.SetProperty( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION, oldWidth );
for( unsigned int i = 0; i < count; i++)
{
int childIndex = start + dir * i;
for( unsigned int i = 0; i < count; i++)
{
int childIndex = start + dir * i;
- LayoutBasePtr childLayout = GetChildAt( childIndex );
+ LayoutItemPtr childLayout = GetChildAt( childIndex );
if( childLayout != nullptr )
{
auto childWidth = childLayout->GetMeasuredWidth();
if( childLayout != nullptr )
{
auto childWidth = childLayout->GetMeasuredWidth();
virtual ~HboxLayout();
/**
virtual ~HboxLayout();
/**
- * @copydoc LayoutBase::DoInitialize
+ * @copydoc LayoutItem::DoInitialize
*/
virtual void DoInitialize() override;
/**
*/
virtual void DoInitialize() override;
/**
- * @copydoc LayoutBase::DoRegisterChildProperties()
+ * @copydoc LayoutItem::DoRegisterChildProperties()
*/
virtual void DoRegisterChildProperties( const std::string& containerType ) override;
/**
*/
virtual void DoRegisterChildProperties( const std::string& containerType ) override;
/**
- * @copydoc LayoutBase::OnChildAdd
+ * @copydoc LayoutItem::OnChildAdd
- virtual void OnChildAdd( LayoutBase& child ) override;
+ virtual void OnChildAdd( LayoutItem& child ) override;
- * @copydoc LayoutBase::OnMeasure
+ * @copydoc LayoutItem::OnMeasure
*/
virtual void OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec ) override;
/**
*/
virtual void OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec ) override;
/**
- * @copydoc LayoutBase::OnLayout
+ * @copydoc LayoutItem::OnLayout
*/
virtual void OnLayout( bool changed, LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b ) override;
*/
virtual void OnLayout( bool changed, LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b ) override;
Debug::Filter* gLogFilter = Debug::Filter::New( Debug::Verbose, false, "LOG_LAYOUT_TREE" );
Debug::Filter* gLogFilter = Debug::Filter::New( Debug::Verbose, false, "LOG_LAYOUT_TREE" );
-void GetLayoutMeasureStateString( std::ostringstream& oss, LayoutBasePtr layout )
+void GetLayoutMeasureStateString( std::ostringstream& oss, LayoutItemPtr layout )
-void LayoutDebugMeasureStateRecurseLayout( LayoutBasePtr layout, int depth );
+void LayoutDebugMeasureStateRecurseLayout( LayoutItemPtr layout, int depth );
void LayoutDebugMeasureStateRecurseActor( Actor root, int depth )
{
void LayoutDebugMeasureStateRecurseActor( Actor root, int depth )
{
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
- LayoutBasePtr layout = controlDataImpl.GetLayout();
+ LayoutItemPtr layout = controlDataImpl.GetLayout();
if( layout != nullptr )
{
if( layout != nullptr )
{
-void LayoutDebugMeasureStateRecurseLayout( LayoutBasePtr layout, int depth )
+void LayoutDebugMeasureStateRecurseLayout( LayoutItemPtr layout, int depth )
{
std::ostringstream oss;
for(int i=0;i<depth;++i) { oss << " "; }; // indent
{
std::ostringstream oss;
for(int i=0;i<depth;++i) { oss << " "; }; // indent
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
- LayoutBasePtr layout = controlDataImpl.GetLayout();
+ LayoutItemPtr layout = controlDataImpl.GetLayout();
if( layout )
{
auto childOwner = layout->GetOwner();
if( layout )
{
auto childOwner = layout->GetOwner();
- auto widthMeasureSpec = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
- auto heightMeasureSpec = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto widthMeasureSpec = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+ auto heightMeasureSpec = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
oss << "LayoutData:" << "( " << widthMeasureSpec << ", " << heightMeasureSpec << ") ";
oss << "LayoutData:" << "( " << widthMeasureSpec << ", " << heightMeasureSpec << ") ";
-void LayoutController::RequestLayout( LayoutBase& layoutBase )
+void LayoutController::RequestLayout( LayoutItem& LayoutItem )
{
DALI_LOG_INFO( gLogFilter, Debug::Concise, "LayoutController::RequestLayout\n" );
mLayoutRequested = true;
// Go up the tree and mark all parents to relayout
{
DALI_LOG_INFO( gLogFilter, Debug::Concise, "LayoutController::RequestLayout\n" );
mLayoutRequested = true;
// Go up the tree and mark all parents to relayout
- LayoutParent* layoutParent = layoutBase.GetParent();
+ LayoutParent* layoutParent = LayoutItem.GetParent();
if( layoutParent )
{
LayoutGroup& layoutGroup = static_cast< LayoutGroup& >( *layoutParent );
if( layoutParent )
{
LayoutGroup& layoutGroup = static_cast< LayoutGroup& >( *layoutParent );
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
- LayoutBasePtr layout = controlDataImpl.GetLayout();
+ LayoutItemPtr layout = controlDataImpl.GetLayout();
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
{
Internal::Control& controlImpl = GetImplementation( control );
Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl );
- LayoutBasePtr layout = controlDataImpl.GetLayout();
+ LayoutItemPtr layout = controlDataImpl.GetLayout();
#include <dali/integration-api/core.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
#include <dali/integration-api/core.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
#include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
namespace Dali
#include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
namespace Dali
/**
* This marks the given layout and all its parents as dirty.
*/
/**
* This marks the given layout and all its parents as dirty.
*/
- void RequestLayout( LayoutBase& layout );
+ void RequestLayout( LayoutItem& layout );
/**
* Measures next level of layouts in the actor hierarchy.
/**
* Measures next level of layouts in the actor hierarchy.
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
-#include <dali-toolkit/internal/layouting/layout-base-data-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
+#include <dali-toolkit/internal/layouting/layout-item-data-impl.h>
#include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
namespace Dali
#include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
namespace Dali
public:
struct ChildLayout
{
public:
struct ChildLayout
{
Toolkit::LayoutGroup::LayoutId layoutId;
};
Toolkit::LayoutGroup::LayoutId layoutId;
};
* limitations under the License.
*/
* limitations under the License.
*/
-#include <dali-toolkit/internal/layouting/layout-base-data-impl.h>
+#include <dali-toolkit/internal/layouting/layout-item-data-impl.h>
#include <dali-toolkit/devel-api/layouting/measured-size.h>
namespace Dali
#include <dali-toolkit/devel-api/layouting/measured-size.h>
namespace Dali
-bool LayoutBase::Impl::sUseZeroUnspecifiedMeasureSpec = false;
+bool LayoutItem::Impl::sUseZeroUnspecifiedMeasureSpec = false;
-LayoutBase::Impl::Impl()
+LayoutItem::Impl::Impl()
: mOwner( nullptr ),
mLayoutParent( nullptr ),
mOldWidthMeasureSpec( 0u ),
: mOwner( nullptr ),
mLayoutParent( nullptr ),
mOldWidthMeasureSpec( 0u ),
* limitations under the License.
*/
* limitations under the License.
*/
-#include <dali-toolkit/devel-api/layouting/layout-base-impl.h>
+#include <dali-toolkit/devel-api/layouting/layout-item-impl.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
#include <dali-toolkit/devel-api/layouting/layout-size.h>
#include <dali-toolkit/devel-api/layouting/layout-controller.h>
#include <dali-toolkit/devel-api/layouting/layout-size.h>
#include <dali/public-api/common/extents.h>
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/object/handle-devel.h>
#include <dali/public-api/common/extents.h>
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/object/handle-devel.h>
-#include <dali-toolkit/devel-api/layouting/layout-base.h>
+#include <dali-toolkit/devel-api/layouting/layout-item.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
-void VboxLayout::OnChildAdd( LayoutBase& child )
+void VboxLayout::OnChildAdd( LayoutItem& child )
{
auto owner = child.GetOwner();
owner.SetProperty( Toolkit::VboxLayout::ChildProperty::WEIGHT, 1.0f );
{
auto owner = child.GetOwner();
owner.SetProperty( Toolkit::VboxLayout::ChildProperty::WEIGHT, 1.0f );
if( childLayout )
{
auto childOwner = childLayout->GetOwner();
if( childLayout )
{
auto childOwner = childLayout->GetOwner();
- auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
+ auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, heightMeasureSpec, 0 );
auto childHeight = childLayout->GetMeasuredHeight();
MeasureChildWithMargins( childLayout, widthMeasureSpec, 0, heightMeasureSpec, 0 );
auto childHeight = childLayout->GetMeasuredHeight();
auto uniformMeasureSpec = MeasureSpec( GetMeasuredWidth(), MeasureSpec::Mode::EXACTLY );
for (int i = 0; i < count; ++i)
{
auto uniformMeasureSpec = MeasureSpec( GetMeasuredWidth(), MeasureSpec::Mode::EXACTLY );
for (int i = 0; i < count; ++i)
{
- LayoutBasePtr childLayout = GetChildAt(i);
+ LayoutItemPtr childLayout = GetChildAt(i);
if( childLayout != nullptr )
{
auto childOwner = childLayout->GetOwner();
if( childLayout != nullptr )
{
auto childOwner = childLayout->GetOwner();
- auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::WIDTH_SPECIFICATION );
- auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION );
+ auto desiredWidth = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::WIDTH_SPECIFICATION );
+ auto desiredHeight = childOwner.GetProperty<int>( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION );
if( desiredWidth == Toolkit::ChildLayoutData::MATCH_PARENT )
{
// Temporarily force children to reuse their old measured height
int oldHeight = desiredHeight;
if( desiredWidth == Toolkit::ChildLayoutData::MATCH_PARENT )
{
// Temporarily force children to reuse their old measured height
int oldHeight = desiredHeight;
- childOwner.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, childLayout->GetMeasuredHeight().mValue );
+ childOwner.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, childLayout->GetMeasuredHeight().mValue );
// Remeasure with new dimensions
MeasureChildWithMargins( childLayout, uniformMeasureSpec, 0, heightMeasureSpec, 0 );
// Remeasure with new dimensions
MeasureChildWithMargins( childLayout, uniformMeasureSpec, 0, heightMeasureSpec, 0 );
- childOwner.SetProperty( Toolkit::LayoutBase::ChildProperty::HEIGHT_SPECIFICATION, oldHeight );
+ childOwner.SetProperty( Toolkit::LayoutItem::ChildProperty::HEIGHT_SPECIFICATION, oldHeight );
for( unsigned int childIndex = 0; childIndex < count; childIndex++)
{
for( unsigned int childIndex = 0; childIndex < count; childIndex++)
{
- LayoutBasePtr childLayout = GetChildAt( childIndex );
+ LayoutItemPtr childLayout = GetChildAt( childIndex );
if( childLayout != nullptr )
{
auto childWidth = childLayout->GetMeasuredWidth();
if( childLayout != nullptr )
{
auto childWidth = childLayout->GetMeasuredWidth();
virtual ~VboxLayout();
/**
virtual ~VboxLayout();
/**
- * @copydoc LayoutBase::DoInitialize
+ * @copydoc LayoutItem::DoInitialize
*/
virtual void DoInitialize() override;
/**
*/
virtual void DoInitialize() override;
/**
- * @copydoc LayoutBase::DoRegisterChildProperties()
+ * @copydoc LayoutItem::DoRegisterChildProperties()
*/
virtual void DoRegisterChildProperties( const std::string& containerType ) override;
/**
*/
virtual void DoRegisterChildProperties( const std::string& containerType ) override;
/**
- * @copydoc LayoutBase::OnChildAdd
+ * @copydoc LayoutItem::OnChildAdd
- virtual void OnChildAdd( LayoutBase& child ) override;
+ virtual void OnChildAdd( LayoutItem& child ) override;
- * @copydoc LayoutBase::OnMeasure
+ * @copydoc LayoutItem::OnMeasure
*/
virtual void OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec ) override;
/**
*/
virtual void OnMeasure( MeasureSpec widthMeasureSpec, MeasureSpec heightMeasureSpec ) override;
/**
- * @copydoc LayoutBase::OnLayout
+ * @copydoc LayoutItem::OnLayout
*/
virtual void OnLayout( bool changed, LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b ) override;
*/
virtual void OnLayout( bool changed, LayoutLength l, LayoutLength t, LayoutLength r, LayoutLength b ) override;
projects / platform / core / uifw / dali-toolkit.git / commitdiff