X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Ftable-view%2Ftable-view-impl.cpp;h=225080154422f0173600a56b8b3497639c397bc9;hp=4f170235286ba151ca455126ba00fb46fd5f00b7;hb=d7638de1a66bed4868e8a9fb2f4d3c03f4ce27f8;hpb=cc82bd9b187cda8fe2c8336b73fd1fa9376cfebd diff --git a/dali-toolkit/internal/controls/table-view/table-view-impl.cpp b/dali-toolkit/internal/controls/table-view/table-view-impl.cpp index 4f17023..2250801 100644 --- a/dali-toolkit/internal/controls/table-view/table-view-impl.cpp +++ b/dali-toolkit/internal/controls/table-view/table-view-impl.cpp @@ -22,8 +22,8 @@ #include #include #include -#include -#include +#include +#include #include #include @@ -31,16 +31,29 @@ using namespace Dali; namespace { +/* + * Custom properties for where to put the actor. + * + * When an actor is add to the tableView through Actor::Add() instead of TableView::AddChild, + * the following custom properties of the actor are checked to decide the actor position inside the table + * + * These non-animatable properties should be registered to the child which would be added to the table + */ +const char * const CELL_INDEX_PROPERTY_NAME("cell-index"); +const char * const ROW_SPAN_PROPERTY_NAME("row-span"); +const char * const COLUMN_SPAN_PROPERTY_NAME("column-span"); +const char * const CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME("cell-horizontal-alignment"); +const char * const CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME("cell-vertical-alignment"); /** * @brief Should the tableview fit around the given actor * * @param[in] actor The child actor to test against - * @param[dimension] The dimnesion to test against + * @param[dimension] The dimension to test against */ -bool FitToChild( Actor actor, Dimension dimension ) +bool FitToChild( Actor actor, Dimension::Type dimension ) { - return actor.GetResizePolicy( dimension ) != FILL_TO_PARENT && actor.GetRelayoutSize( dimension ) > 0.0f; + return actor.GetResizePolicy( dimension ) != ResizePolicy::FILL_TO_PARENT && actor.GetRelayoutSize( dimension ) > 0.0f; } #if defined(DEBUG_ENABLED) @@ -49,7 +62,9 @@ bool FitToChild( Actor actor, Dimension dimension ) #define TABLEVIEW_TAG "DALI Toolkit::TableView " #define TV_LOG(fmt, args...) Debug::LogMessage(Debug::DebugInfo, TABLEVIEW_TAG fmt, ## args) +//#define TABLEVIEW_DEBUG 1 +#if defined(TABLEVIEW_DEBUG) void PrintArray( Array2d& array ) { TV_LOG( "Array2d size [%d,%d] \n", array.GetRows(), array.GetColumns() ); @@ -60,11 +75,13 @@ void PrintArray( Array2d& array ) { Dali::Toolkit::Internal::TableView::CellData data = array[i][j]; char actor = ' '; + std::string actorName; if( data.actor ) { actor = 'A'; + actorName = data.actor.GetName(); } - TV_LOG("Array[%d,%d]=%c %d,%d,%d,%d ", i, j, actor, + TV_LOG("Array[%d,%d]=%c %s %d,%d,%d,%d ", i, j, actor, actorName.c_str(), data.position.rowIndex, data.position.columnIndex, data.position.rowSpan, data.position.columnSpan ); } @@ -99,6 +116,7 @@ void PrintVector( std::vector& array ) } TV_LOG( "\n" ); } +#endif // defined(TABLEVIEW_DEBUG) #endif // defined(DEBUG_ENABLED) } // namespace @@ -124,23 +142,39 @@ BaseHandle Create() // Setup properties, signals and actions using the type-registry. DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TableView, Toolkit::Control, Create ); -DALI_PROPERTY_REGISTRATION( TableView, "rows", UNSIGNED_INTEGER, ROWS ) -DALI_PROPERTY_REGISTRATION( TableView, "columns", UNSIGNED_INTEGER, COLUMNS ) -DALI_PROPERTY_REGISTRATION( TableView, "cell-padding", VECTOR2, CELL_PADDING ) -DALI_PROPERTY_REGISTRATION( TableView, "layout-rows", MAP, LAYOUT_ROWS ) -DALI_PROPERTY_REGISTRATION( TableView, "layout-columns", MAP, LAYOUT_COLUMNS ) +DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "rows", UNSIGNED_INTEGER, ROWS ) +DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "columns", UNSIGNED_INTEGER, COLUMNS ) +DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "cell-padding", VECTOR2, CELL_PADDING ) +DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layout-rows", MAP, LAYOUT_ROWS ) +DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layout-columns", MAP, LAYOUT_COLUMNS ) DALI_TYPE_REGISTRATION_END() -const Scripting::StringEnum< Toolkit::TableView::LayoutPolicy > LAYOUT_POLICY_STRING_TABLE[] = +const Scripting::StringEnum LAYOUT_POLICY_STRING_TABLE[] = { { "fixed", Toolkit::TableView::FIXED }, { "relative", Toolkit::TableView::RELATIVE }, - { "fill", Toolkit::TableView::FILL } + { "fill", Toolkit::TableView::FILL }, + { "fit", Toolkit::TableView::FIT } }; - const unsigned int LAYOUT_POLICY_STRING_TABLE_COUNT = sizeof(LAYOUT_POLICY_STRING_TABLE) / sizeof( LAYOUT_POLICY_STRING_TABLE[0] ); +const Scripting::StringEnum HORIZONTAL_ALIGNMENT_STRING_TABLE[] = +{ + {"left", HorizontalAlignment::LEFT}, + {"center", HorizontalAlignment::CENTER}, + {"right", HorizontalAlignment::RIGHT} +}; +const unsigned int HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof(HORIZONTAL_ALIGNMENT_STRING_TABLE) / sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE[0] ); + +const Scripting::StringEnum VERTICAL_ALIGNMENT_STRING_TABLE[] = +{ + {"top", VerticalAlignment::TOP}, + {"center", VerticalAlignment::CENTER}, + {"bottom", VerticalAlignment::BOTTOM} +}; +const unsigned int VERTICAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof(VERTICAL_ALIGNMENT_STRING_TABLE) / sizeof( VERTICAL_ALIGNMENT_STRING_TABLE[0] ); + } // Unnamed namespace Toolkit::TableView TableView::New( unsigned int initialRows, unsigned int initialColumns ) @@ -164,10 +198,7 @@ bool TableView::AddChild( Actor& child, const Toolkit::TableView::CellPosition& DALI_ASSERT_ALWAYS( child ); // if child is already parented, we adopt it - if( child.GetParent() ) - { - child.GetParent().Remove( child ); - } + child.Unparent(); // check if we need to expand our data array if( position.rowIndex >= mCellData.GetRows() ) @@ -192,50 +223,33 @@ bool TableView::AddChild( Actor& child, const Toolkit::TableView::CellPosition& // adopt the child Self().Add( child ); - // put the actor to the main cell - CellData& data = mCellData[ position.rowIndex ][ position.columnIndex ]; - data.actor = child; - data.position = position; - // if child spans multiple rows of columns - bool spanned = false; - if( position.rowSpan > 1 ) + if( ( position.rowSpan > 1 ) && ( position.rowIndex + position.rowSpan > mCellData.GetRows() ) ) { - // span might go outside table - if( position.rowIndex + position.rowSpan > mCellData.GetRows() ) - { - // increase table size for the full span, only increasing rows - ResizeContainers( position.rowIndex + position.rowSpan, mCellData.GetColumns() ); - } - - spanned = true; + // increase table size for the full span, only increasing rows + ResizeContainers( position.rowIndex + position.rowSpan, mCellData.GetColumns() ); } - if( position.columnSpan > 1 ) + if( ( position.columnSpan > 1 ) && ( position.columnIndex + position.columnSpan > mCellData.GetColumns() ) ) { - // span might go outside table - if( position.columnIndex + position.columnSpan > mCellData.GetColumns() ) - { - // increase table size for the full span, only increasing columns - ResizeContainers( mCellData.GetRows(), position.columnIndex + position.columnSpan ); - } - - spanned = true; + // increase table size for the full span, only increasing columns + ResizeContainers( mCellData.GetRows(), position.columnIndex + position.columnSpan ); } - // if it spanned multiple rows, put the cellinfo in all of those - if( spanned ) + // Fill in all cells that need the data + CellData data; + data.actor = child; + data.position = position; + + for( unsigned int row = position.rowIndex; row < ( position.rowIndex + position.rowSpan ); ++row ) { - for( unsigned int row = position.rowIndex; row < ( position.rowIndex + position.rowSpan ); ++row ) + // store same information to all cells, this way we can identify + // if a cell is the prime location of an actor or a spanned one + for( unsigned int column = position.columnIndex; column < ( position.columnIndex + position.columnSpan ); ++column ) { // store same information to all cells, this way we can identify // if a cell is the prime location of an actor or a spanned one - for( unsigned int column = position.columnIndex; column < ( position.columnIndex + position.columnSpan ); ++column ) - { - // store same information to all cells, this way we can identify - // if a cell is the prime location of an actor or a spanned one - mCellData[ row ][ column ] = data; - } + mCellData[ row ][ column ] = data; } } @@ -556,44 +570,44 @@ Size TableView::GetCellPadding() return mPadding; } -void TableView::SetRowPolicy( unsigned int rowIndex, CellSizePolicy policy ) +void TableView::SetFitHeight( unsigned int rowIndex ) { DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() ); - if( mRowData[ rowIndex ].sizePolicy != policy ) + if( mRowData[ rowIndex ].sizePolicy != Toolkit::TableView::FIT ) { - mRowData[ rowIndex ].sizePolicy = policy; + mRowData[ rowIndex ].sizePolicy = Toolkit::TableView::FIT; mRowColumnDirty = true; RelayoutRequest(); } } -TableView::CellSizePolicy TableView::GetRowPolicy( unsigned int rowIndex ) const +bool TableView::IsFitHeight( unsigned int rowIndex ) const { DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() ); - return mRowData[ rowIndex ].sizePolicy; + return mRowData[ rowIndex ].sizePolicy == Toolkit::TableView::FIT; } -void TableView::SetColumnPolicy( unsigned int columnIndex, CellSizePolicy policy ) +void TableView::SetFitWidth( unsigned int columnIndex ) { DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() ); - if( mColumnData[ columnIndex ].sizePolicy != policy ) + if( mColumnData[ columnIndex ].sizePolicy != Toolkit::TableView::FIT ) { - mColumnData[ columnIndex ].sizePolicy = policy; + mColumnData[ columnIndex ].sizePolicy = Toolkit::TableView::FIT; mRowColumnDirty = true; RelayoutRequest(); } } -TableView::CellSizePolicy TableView::GetColumnPolicy( unsigned int columnIndex ) const +bool TableView::IsFitWidth( unsigned int columnIndex ) const { DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() ); - return mColumnData[ columnIndex ].sizePolicy; + return mColumnData[ columnIndex ].sizePolicy == Toolkit::TableView::FIT; } void TableView::SetFixedHeight( unsigned int rowIndex, float height ) @@ -602,7 +616,7 @@ void TableView::SetFixedHeight( unsigned int rowIndex, float height ) RowColumnData& data = mRowData[ rowIndex ]; data.size = height; - data.sizePolicy = FIXED; + data.sizePolicy = Toolkit::TableView::FIXED; mRowColumnDirty = true; RelayoutRequest(); @@ -621,7 +635,7 @@ void TableView::SetFixedWidth( unsigned int columnIndex, float width ) RowColumnData& data = mColumnData[ columnIndex ]; data.size = width; - data.sizePolicy = FIXED; + data.sizePolicy = Toolkit::TableView::FIXED; mRowColumnDirty = true; RelayoutRequest(); @@ -640,8 +654,7 @@ void TableView::SetRelativeHeight( unsigned int rowIndex, float heightPercentage RowColumnData& data = mRowData[ rowIndex ]; data.fillRatio = heightPercentage; - data.userFillRatio = true; - data.sizePolicy = FILL; + data.sizePolicy = Toolkit::TableView::RELATIVE; mRowColumnDirty = true; RelayoutRequest(); @@ -660,8 +673,7 @@ void TableView::SetRelativeWidth( unsigned int columnIndex, float widthPercentag RowColumnData& data = mColumnData[ columnIndex ]; data.fillRatio = widthPercentage; - data.userFillRatio = true; - data.sizePolicy = FILL; + data.sizePolicy = Toolkit::TableView::RELATIVE; mRowColumnDirty = true; RelayoutRequest(); @@ -686,29 +698,29 @@ void TableView::CalculateRowColumnData() } } -void TableView::OnCalculateRelayoutSize( Dimension dimension ) +void TableView::OnCalculateRelayoutSize( Dimension::Type dimension ) { CalculateRowColumnData(); - if( dimension & WIDTH ) + if( dimension & Dimension::WIDTH ) { - CalculateFixedSizes( mColumnData, WIDTH ); + CalculateFixedSizes( mColumnData, Dimension::WIDTH ); mFixedTotals.width = CalculateTotalFixedSize( mColumnData ); } - if( dimension & HEIGHT ) + if( dimension & Dimension::HEIGHT ) { - CalculateFixedSizes( mRowData, HEIGHT ); + CalculateFixedSizes( mRowData, Dimension::HEIGHT ); mFixedTotals.height = CalculateTotalFixedSize( mRowData ); } } -void TableView::OnLayoutNegotiated( float size, Dimension dimension ) +void TableView::OnLayoutNegotiated( float size, Dimension::Type dimension ) { CalculateRowColumnData(); // Calculate the value of all relative sized rows and columns - if( dimension & WIDTH ) + if( dimension & Dimension::WIDTH ) { float remainingSize = size - mFixedTotals.width; if( remainingSize < 0.0f ) @@ -719,7 +731,7 @@ void TableView::OnLayoutNegotiated( float size, Dimension dimension ) CalculateRelativeSizes( mColumnData, remainingSize ); } - if( dimension & HEIGHT ) + if( dimension & Dimension::HEIGHT ) { float remainingSize = size - mFixedTotals.height; if( remainingSize < 0.0f ) @@ -735,45 +747,89 @@ void TableView::OnRelayout( const Vector2& size, RelayoutContainer& container ) { CalculateRowColumnData(); - // Go through the layout data - float cumulatedHeight = 0.0f; - - const unsigned int rowCount = mCellData.GetRows(); + // update every column position in ColumnData array + float cumulatedWidth = 0.0f; const unsigned int columnCount = mCellData.GetColumns(); + for( unsigned int column = 0; column < columnCount; ++column ) + { + mColumnData[column].position = cumulatedWidth; + cumulatedWidth += mColumnData[ column ].size; + } + // update every row position in RowData array + float cumulatedHeight = 0.0f; + const unsigned int rowCount = mCellData.GetRows(); for( unsigned int row = 0; row < rowCount; ++row ) { - float cumulatedWidth = 0.0f; + mRowData[row].position = cumulatedHeight; + cumulatedHeight += mRowData[ row ].size; + } + // Go through the layout data + for( unsigned int row = 0; row < rowCount; ++row ) + { for( unsigned int column = 0; column < columnCount; ++column ) { - Actor& actor = mCellData[ row ][ column ].actor; - const Toolkit::TableView::CellPosition position = mCellData[ row ][ column ].position; + CellData& cellData= mCellData[ row ][ column ]; + Actor& actor = cellData.actor; + const Toolkit::TableView::CellPosition position = cellData.position; // If there is an actor and this is the main cell of the actor. - // An actor can be in multiple cells if its row or columnspan is more than 1. + // An actor can be in multiple cells if its row or column span is more than 1. // We however must lay out each actor only once. - if( actor && ( position.rowIndex == row ) && ( position.columnIndex == column ) ) + if( actor && position.rowIndex == row && position.columnIndex == column ) { - // Anchor actor to top left of table view + // Anchor actor to top left of the cell actor.SetAnchorPoint( AnchorPoint::TOP_LEFT ); actor.SetParentOrigin( ParentOrigin::TOP_LEFT ); + Vector2( actor.GetRelayoutSize( Dimension::WIDTH ), actor.GetRelayoutSize( Dimension::HEIGHT ) ); + Padding padding; actor.GetPadding( padding ); - Vector3 actorPosition( cumulatedWidth + mPadding.width + padding.left, // Left padding - cumulatedHeight + mPadding.height + padding.top, // Top padding - 0.0f ); - actor.SetPosition( actorPosition ); - } + if( cellData.horizontalAlignment == HorizontalAlignment::LEFT ) + { + actor.SetX( mColumnData[column].position + mPadding.width + padding.left ); + } + else + { + float cellRightPosition = column+position.columnSpan < columnCount ? mColumnData[column+position.columnSpan].position : cumulatedWidth; - DALI_ASSERT_DEBUG( column < mColumnData.Size() ); - cumulatedWidth += mColumnData[ column ].size; - } + if( cellData.horizontalAlignment == HorizontalAlignment::RIGHT ) + { + actor.SetX( cellRightPosition - mPadding.width - padding.right - actor.GetRelayoutSize( Dimension::WIDTH ) ); + } + else //if( cellData.horizontalAlignment == HorizontalAlignment::CENTER ) + { + actor.SetX( (mColumnData[column].position + cellRightPosition + + padding.left - padding.right + - actor.GetRelayoutSize( Dimension::WIDTH )) * 0.5f ); + } + } - DALI_ASSERT_DEBUG( row < mRowData.Size() ); - cumulatedHeight += mRowData[ row ].size; + if( cellData.verticalAlignment == VerticalAlignment::TOP ) + { + actor.SetY( mRowData[row].position + mPadding.height + padding.top ); + } + else + { + float cellBottomPosition = row+position.rowSpan < rowCount ? mRowData[row+position.rowSpan].position : cumulatedHeight; + + if( cellData.verticalAlignment == VerticalAlignment::BOTTOM ) + + { + actor.SetY( cellBottomPosition - mPadding.height - padding.bottom - actor.GetRelayoutSize( Dimension::HEIGHT ) ); + } + else //if( cellData.verticalAlignment = VerticalAlignment::CENTER ) + { + actor.SetY( (mRowData[row].position + cellBottomPosition + + padding.top - padding.bottom + - actor.GetRelayoutSize( Dimension::HEIGHT )) * 0.5f ); + } + } + } + } } } @@ -819,12 +875,12 @@ void TableView::SetProperty( BaseObject* object, Property::Index index, const Pr } case Toolkit::TableView::Property::LAYOUT_ROWS: { - SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedHeight, &TableView::SetRelativeHeight, value ); + SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedHeight, &TableView::SetRelativeHeight, &TableView::SetFitHeight, value ); break; } case Toolkit::TableView::Property::LAYOUT_COLUMNS: { - SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedWidth, &TableView::SetRelativeWidth, value ); + SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedWidth, &TableView::SetRelativeWidth, &TableView::SetFitWidth, value ); break; } } @@ -881,29 +937,49 @@ void TableView::OnControlChildAdd( Actor& child ) return; } - RelayoutRequest(); - // Test properties on actor + HorizontalAlignment::Type horizontalAlignment = HorizontalAlignment::LEFT; + VerticalAlignment::Type verticalAlignment = VerticalAlignment::TOP; + if( child.GetPropertyIndex( CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME ) != Property::INVALID_INDEX ) + { + std::string value = child.GetProperty( child.GetPropertyIndex(CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME) ).Get(); + Scripting::GetEnumeration< HorizontalAlignment::Type >( value.c_str(), + HORIZONTAL_ALIGNMENT_STRING_TABLE, + HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT, + horizontalAlignment ); + } + if( child.GetPropertyIndex( CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME ) != Property::INVALID_INDEX ) + { + std::string value = child.GetProperty( child.GetPropertyIndex(CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME) ).Get(); + Scripting::GetEnumeration< VerticalAlignment::Type >( value.c_str(), + VERTICAL_ALIGNMENT_STRING_TABLE, + VERTICAL_ALIGNMENT_STRING_TABLE_COUNT, + verticalAlignment ); + } + + Toolkit::TableView::CellPosition cellPosition; - if( child.GetPropertyIndex(Toolkit::TableView::ROW_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX ) + if( child.GetPropertyIndex(ROW_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX ) { - cellPosition.rowSpan = static_cast( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::ROW_SPAN_PROPERTY_NAME) ).Get() ); + cellPosition.rowSpan = static_cast( child.GetProperty( child.GetPropertyIndex(ROW_SPAN_PROPERTY_NAME) ).Get() ); } - if( child.GetPropertyIndex(Toolkit::TableView::COLUMN_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX ) + if( child.GetPropertyIndex(COLUMN_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX ) { - cellPosition.columnSpan = static_cast( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::COLUMN_SPAN_PROPERTY_NAME) ).Get() ); + cellPosition.columnSpan = static_cast( child.GetProperty( child.GetPropertyIndex(COLUMN_SPAN_PROPERTY_NAME) ).Get() ); } - if( child.GetPropertyIndex(Toolkit::TableView::CELL_INDICES_PROPERTY_NAME) != Property::INVALID_INDEX ) + if( child.GetPropertyIndex(CELL_INDEX_PROPERTY_NAME) != Property::INVALID_INDEX ) { - Vector2 indices = child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::CELL_INDICES_PROPERTY_NAME) ).Get(); + Vector2 indices = child.GetProperty( child.GetPropertyIndex(CELL_INDEX_PROPERTY_NAME) ).Get(); cellPosition.rowIndex = static_cast( indices.x ); cellPosition.columnIndex = static_cast( indices.y ); AddChild( child, cellPosition ); + SetCellAlignment(cellPosition, horizontalAlignment, verticalAlignment); // Do not continue + RelayoutRequest(); return; } @@ -921,9 +997,12 @@ void TableView::OnControlChildAdd( Actor& child ) data.actor = child; data.position.columnIndex = column; data.position.rowIndex = row; + data.horizontalAlignment = horizontalAlignment; + data.verticalAlignment = verticalAlignment; mCellData[ row ][ column ] = data; // Don't continue + RelayoutRequest(); return; } } @@ -938,7 +1017,10 @@ void TableView::OnControlChildAdd( Actor& child ) data.actor = child; data.position.rowIndex = rowCount; data.position.columnIndex = 0; + data.horizontalAlignment = horizontalAlignment; + data.verticalAlignment = verticalAlignment; mCellData[ rowCount ][ 0 ] = data; + RelayoutRequest(); } void TableView::OnControlChildRemove( Actor& child ) @@ -1060,29 +1142,46 @@ bool TableView::RemoveAllInstances( const Actor& child ) void TableView::SetHeightOrWidthProperty(TableView& tableViewImpl, void(TableView::*funcFixed)(unsigned int, float), void(TableView::*funcRelative)(unsigned int, float), + void(TableView::*funcFit)(unsigned int), const Property::Value& value ) { - if( Property::MAP == value.GetType() ) + Property::Map* map = value.GetMap(); + if( map ) { - Property::Map map = value.Get(); - unsigned int rowIndex(0); - for ( unsigned int i = 0, count = map.Count(); i < count; ++i ) + unsigned int index(0); + for ( unsigned int i = 0, count = map->Count(); i < count; ++i ) { - Property::Value& item = map.GetValue(i); + Property::Value& item = map->GetValue(i); + Property::Map* childMap = item.GetMap(); - if( std::istringstream(map.GetKey(i)) >> rowIndex // the key is a number - && Property::MAP == item.GetType()) + std::istringstream( map->GetKey(i) ) >> index; + if( childMap ) { - if( item.HasKey( "policy" ) && item.HasKey( "value" ) ) + Property::Value* policy = childMap->Find( "policy" ); + Property::Value* value = childMap->Find( "value" ); + if( policy && value ) { - Toolkit::TableView::LayoutPolicy policy = Scripting::GetEnumeration< Toolkit::TableView::LayoutPolicy >( item.GetValue("policy").Get().c_str(), LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT ); - if( policy == Toolkit::TableView::FIXED ) + std::string policyValue; + policy->Get( policyValue ); + Toolkit::TableView::LayoutPolicy policy; + if( Scripting::GetEnumeration< Toolkit::TableView::LayoutPolicy >( policyValue.c_str(), + LAYOUT_POLICY_STRING_TABLE, + LAYOUT_POLICY_STRING_TABLE_COUNT, + policy ) ) { - (tableViewImpl.*funcFixed)( rowIndex, item.GetValue("value").Get() ); - } - else if( policy == Toolkit::TableView::RELATIVE ) - { - (tableViewImpl.*funcRelative)( rowIndex, item.GetValue("value").Get() ); + if( policy == Toolkit::TableView::FIXED ) + { + (tableViewImpl.*funcFixed)( index, value->Get() ); + } + else if( policy == Toolkit::TableView::RELATIVE ) + { + (tableViewImpl.*funcRelative)( index, value->Get() ); + } + else if( policy == Toolkit::TableView::FIT ) + { + (tableViewImpl.*funcFit)( index ); + } + // do nothing for FILL policy } } } @@ -1106,49 +1205,56 @@ Property::Value TableView::GetColumnWidthsPropertyValue() void TableView::GetMapPropertyValue( const RowColumnArray& data, Property::Map& map ) { - std::string fixedPolicy( Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FIXED, LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT ) ); - std::string relativePolicy( Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::RELATIVE, LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT ) ); + const char* fixedPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FIXED, + LAYOUT_POLICY_STRING_TABLE, + LAYOUT_POLICY_STRING_TABLE_COUNT ); + const char* relativePolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::RELATIVE, + LAYOUT_POLICY_STRING_TABLE, + LAYOUT_POLICY_STRING_TABLE_COUNT ); + const char* fillPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FILL, + LAYOUT_POLICY_STRING_TABLE, + LAYOUT_POLICY_STRING_TABLE_COUNT ); + const char* fitPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FIT, + LAYOUT_POLICY_STRING_TABLE, + LAYOUT_POLICY_STRING_TABLE_COUNT ); const RowColumnArray::SizeType count = data.Size(); for( RowColumnArray::SizeType i = 0; i < count; i++ ) { const RowColumnData& dataInstance = data[ i ]; + Property::Map item; switch( dataInstance.sizePolicy ) { - case FIXED: + case Toolkit::TableView::FIXED: { - Property::Map item; item[ "policy" ] = fixedPolicy; item[ "value" ] = dataInstance.size; - - std::ostringstream ss; - ss << i; - - map[ ss.str() ] = item; - break; } - - case FILL: + case Toolkit::TableView::RELATIVE: { - Property::Map item; item[ "policy" ] = relativePolicy; item[ "value" ] = dataInstance.fillRatio; - - std::ostringstream ss; - ss << i; - - map[ ss.str() ] = item; - break; } - + case Toolkit::TableView::FIT: + { + item[ "policy" ] = fitPolicy; + item[ "value" ] = 0.f; + break; + } + case Toolkit::TableView::FILL: default: { + item[ "policy" ] = fillPolicy; + item[ "value" ] = 0.f; break; } } + std::ostringstream ss; + ss << i; + map[ ss.str() ] = item; } } @@ -1157,7 +1263,7 @@ TableView::~TableView() // nothing to do } -Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled) +Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) { Actor nextFocusableActor; @@ -1180,7 +1286,7 @@ Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolki switch ( direction ) { - case Toolkit::Control::Left: + case Toolkit::Control::KeyboardFocus::LEFT: { if(--currentColumn < 0) { @@ -1193,7 +1299,7 @@ Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolki } break; } - case Toolkit::Control::Right: + case Toolkit::Control::KeyboardFocus::RIGHT: { if(++currentColumn > numberOfColumns - 1) { @@ -1206,7 +1312,7 @@ Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolki } break; } - case Toolkit::Control::Up: + case Toolkit::Control::KeyboardFocus::UP: { if(--currentRow < 0) { @@ -1215,7 +1321,7 @@ Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolki } break; } - case Toolkit::Control::Down: + case Toolkit::Control::KeyboardFocus::DOWN: { if(++currentRow > numberOfRows - 1) @@ -1249,7 +1355,7 @@ Vector3 TableView::GetNaturalSize() return Vector3( mFixedTotals.width, mFixedTotals.height, 1.0f ); } -float TableView::CalculateChildSize( const Actor& child, Dimension dimension ) +float TableView::CalculateChildSize( const Actor& child, Dimension::Type dimension ) { CalculateRowColumnData(); @@ -1273,13 +1379,14 @@ float TableView::CalculateChildSize( const Actor& child, Dimension dimension ) { switch( dimension ) { - case WIDTH: + case Dimension::WIDTH: { float cellSize = 0.0f; // Accumulate the width for( unsigned int i = 0; i < position.columnSpan; ++i ) { + DALI_ASSERT_DEBUG( column + i < mColumnData.Size() ); cellSize += mColumnData[ column + i ].size; } @@ -1293,18 +1400,19 @@ float TableView::CalculateChildSize( const Actor& child, Dimension dimension ) return cellSize; } - case HEIGHT: + case Dimension::HEIGHT: { float cellSize = 0.0f; // Accumulate the height for( unsigned int i = 0; i < position.rowSpan; ++i ) { + DALI_ASSERT_DEBUG( row + i < mRowData.Size() ); cellSize += mRowData[ row + i ].size; } // Apply padding - cellSize -= mPadding.width * 2.0f; + cellSize -= mPadding.height * 2.0f; if( cellSize < 0.0f ) { cellSize = 0.0f; @@ -1326,7 +1434,7 @@ float TableView::CalculateChildSize( const Actor& child, Dimension dimension ) return 0.0f; // Child not found } -bool TableView::RelayoutDependentOnChildren( Dimension dimension ) +bool TableView::RelayoutDependentOnChildren( Dimension::Type dimension ) { if ( Control::RelayoutDependentOnChildren( dimension ) ) { @@ -1369,16 +1477,13 @@ void TableView::ComputeRelativeSizes( RowColumnArray& data ) { RowColumnData& dataInstance = data[ i ]; - if( dataInstance.sizePolicy == FILL ) + if( dataInstance.sizePolicy == Toolkit::TableView::RELATIVE ) { - if( dataInstance.userFillRatio ) - { - relativeTotal += dataInstance.fillRatio; - } - else - { - fillData.PushBack( &dataInstance ); - } + relativeTotal += dataInstance.fillRatio; + } + else if(dataInstance.sizePolicy == Toolkit::TableView::FILL) + { + fillData.PushBack( &dataInstance ); } } @@ -1412,8 +1517,9 @@ float TableView::CalculateTotalFixedSize( const RowColumnArray& data ) switch( dataInstance.sizePolicy ) { - case FIXED: - case FIT: + // we have absolute size to FIXED and FIT column/row and relative size for RELATIVE and FILL column/row + case Toolkit::TableView::FIXED: + case Toolkit::TableView::FIT: { totalSize += dataInstance.size; break; @@ -1429,34 +1535,58 @@ float TableView::CalculateTotalFixedSize( const RowColumnArray& data ) return totalSize; } -void TableView::CalculateFixedSizes( RowColumnArray& data, Dimension dimension ) +Vector2 TableView::GetCellPadding( Dimension::Type dimension ) +{ + switch( dimension ) + { + case Dimension::WIDTH: + { + return Vector2( mPadding.x, mPadding.x ); + } + case Dimension::HEIGHT: + { + return Vector2( mPadding.y, mPadding.y ); + } + default: + { + break; + } + } + + return Vector2(); +} + +void TableView::CalculateFixedSizes( RowColumnArray& data, Dimension::Type dimension ) { + Vector2 cellPadding = GetCellPadding( dimension ); + const unsigned int dataCount = data.Size(); for( unsigned int i = 0; i < dataCount; ++i ) { RowColumnData& dataInstance = data[ i ]; - if( dataInstance.sizePolicy == FIT ) + if( dataInstance.sizePolicy == Toolkit::TableView::FIT ) { // Find the size of the biggest actor in the row or column float maxActorHeight = 0.0f; - unsigned int fitCount = ( dimension == WIDTH ) ? mCellData.GetRows() : mCellData.GetColumns(); + unsigned int fitCount = ( dimension == Dimension::WIDTH ) ? mCellData.GetRows() : mCellData.GetColumns(); for( unsigned int j = 0; j < fitCount; ++j ) { - unsigned int row = ( dimension == WIDTH ) ? j : i; - unsigned int column = ( dimension == WIDTH ) ? i : j; + unsigned int row = ( dimension == Dimension::WIDTH ) ? j : i; + unsigned int column = ( dimension == Dimension::WIDTH ) ? i : j; DALI_ASSERT_DEBUG( row < mCellData.GetRows() ); DALI_ASSERT_DEBUG( column < mCellData.GetColumns() ); - Actor& actor = mCellData[ row ][ column ].actor; + const CellData& cellData = mCellData[ row ][ column ]; + const Actor& actor = cellData.actor; if( actor ) { - if( FitToChild( actor, dimension ) ) + if( FitToChild( actor, dimension ) && ( dimension == Dimension::WIDTH ) ? ( cellData.position.columnSpan == 1 ) : ( cellData.position.rowSpan == 1 ) ) { - maxActorHeight = std::max( maxActorHeight, actor.GetRelayoutSize( dimension ) ); + maxActorHeight = std::max( maxActorHeight, actor.GetRelayoutSize( dimension ) + cellPadding.x + cellPadding.y ); } } } @@ -1474,7 +1604,7 @@ void TableView::CalculateRelativeSizes( RowColumnArray& data, float size ) { RowColumnData& dataInstance = data[ i ]; - if( dataInstance.sizePolicy == FILL ) + if( dataInstance.sizePolicy == Toolkit::TableView::FILL || dataInstance.sizePolicy == Toolkit::TableView::RELATIVE) { dataInstance.size = dataInstance.fillRatio * size; } @@ -1485,7 +1615,7 @@ bool TableView::FindFit( const RowColumnArray& data ) { for( unsigned int i = 0, count = data.Size(); i < count; ++i ) { - if( data[ i ].sizePolicy == FIT ) + if( data[ i ].sizePolicy == Toolkit::TableView::FIT ) { return true; }