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=bac04020cc87a74aac2e46d6a5d1940e28038898;hp=3e9eaf127cd62c317f8066c2368ffae6b35d4092;hb=e9d852fcdacc5788785bfe0b617bd757794e8208;hpb=5cf3fe5c50e9c6bd3e52898af024cb29f6881d8c

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 3e9eaf1..bac0402 100644
--- a/dali-toolkit/internal/controls/table-view/table-view-impl.cpp
+++ b/dali-toolkit/internal/controls/table-view/table-view-impl.cpp
@@ -31,12 +31,25 @@ 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("cellIndex");
+const char * const ROW_SPAN_PROPERTY_NAME("rowSpan");
+const char * const COLUMN_SPAN_PROPERTY_NAME("columnSpan");
+const char * const CELL_HORIZONTAL_ALIGNMENT_PROPERTY_NAME("cellHorizontalAlignment");
+const char * const CELL_VERTICAL_ALIGNMENT_PROPERTY_NAME("cellVerticalAlignment");
 
 /**
  * @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::Type dimension )
 {
@@ -129,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( 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_PROPERTY_REGISTRATION( Toolkit, TableView, "rows",           INTEGER, ROWS           )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "columns",        INTEGER, COLUMNS        )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "cellPadding",    VECTOR2, CELL_PADDING   )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutRows",     MAP,     LAYOUT_ROWS    )
+DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutColumns",  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 )
@@ -169,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() )
@@ -228,6 +254,15 @@ bool TableView::AddChild( Actor& child, const Toolkit::TableView::CellPosition&
   }
 
   // Relayout the whole table
+  if( mRowData[position.rowIndex].sizePolicy == Toolkit::TableView::FIT && position.rowSpan == 1 )
+  {
+    mRowDirty = true;
+  }
+  if( mColumnData[position.columnIndex].sizePolicy == Toolkit::TableView::FIT && position.columnSpan == 1 )
+  {
+    mColumnDirty = true;
+  }
+
   RelayoutRequest();
 
   return true;    // Addition successful
@@ -252,12 +287,20 @@ Actor TableView::RemoveChildAt( const Toolkit::TableView::CellPosition& position
   if( child )
   {
     RelayoutingLock lock( *this );
-    // Remove the child, this will trigger a call to OnControlChildRemove
+    // Remove the child, this will trigger a call to OnChildRemove
     Self().Remove( child );
 
     // relayout the table only if instances were found
     if( RemoveAllInstances( child ) )
     {
+      if( mRowData[position.rowIndex].sizePolicy == Toolkit::TableView::FIT )
+      {
+        mRowDirty = true;
+      }
+      if( mColumnData[position.columnIndex].sizePolicy == Toolkit::TableView::FIT )
+      {
+        mColumnDirty = true;
+      }
       RelayoutRequest();
     }
   }
@@ -328,7 +371,7 @@ void TableView::InsertRow( unsigned int rowIndex )
   mRowData.Insert( mRowData.Begin() + rowIndex, RowColumnData() );
 
   // Sizes may have changed, so relayout
-  mRowColumnDirty = true;
+  mRowDirty = true;
   RelayoutRequest();
 }
 
@@ -369,7 +412,7 @@ void TableView::DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed )
       else if( row >= rowIndex )    // If below of or at the inserted row, decrease row index
       {
         // Decrement index
-        if( position.rowIndex > 1 )
+        if( position.rowIndex > 0 )
         {
           position.rowIndex--;
         }
@@ -384,7 +427,10 @@ void TableView::DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed )
   mRowData.Erase( mRowData.Begin() + rowIndex );
 
   // Sizes may have changed, so relayout
-  mRowColumnDirty = true;
+  mRowDirty = true;
+  // it is possible that the deletion of row leads to remove of child which might further lead to the change of FIT column
+  mColumnDirty = true;
+
   RelayoutRequest();
 }
 
@@ -427,7 +473,7 @@ void TableView::InsertColumn( unsigned int columnIndex )
   mColumnData.Insert( mColumnData.Begin() + columnIndex, RowColumnData() );
 
   // Sizes may have changed so relayout
-  mRowColumnDirty = true;
+  mColumnDirty = true;
   RelayoutRequest();
 }
 
@@ -483,7 +529,10 @@ void TableView::DeleteColumn( unsigned int columnIndex, std::vector<Actor>& remo
   mColumnData.Erase( mColumnData.Begin() + columnIndex );
 
   // Size may have changed so relayout
-  mRowColumnDirty = true;
+  mColumnDirty = true;
+  // it is possible that the deletion of column leads to remove of child which might further lead to the change of FIT row
+  mRowDirty = true;
+
   RelayoutRequest();
 }
 
@@ -524,7 +573,8 @@ void TableView::Resize( unsigned int rows, unsigned int columns, std::vector<Act
   RemoveAndGetLostActors( lost, removed, rowsRemoved, columnsRemoved );
 
   // Sizes may have changed so request a relayout
-  mRowColumnDirty = true;
+  mRowDirty = true;
+  mColumnDirty = true;
   RelayoutRequest();
 }
 
@@ -544,44 +594,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;
+    mRowDirty = 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;
+    mColumnDirty = 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 )
@@ -590,9 +640,9 @@ 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;
+  mRowDirty = true;
   RelayoutRequest();
 }
 
@@ -609,9 +659,9 @@ 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;
+  mColumnDirty = true;
   RelayoutRequest();
 }
 
@@ -628,10 +678,9 @@ 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;
+  mRowDirty = true;
   RelayoutRequest();
 }
 
@@ -648,10 +697,9 @@ 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;
+  mColumnDirty = true;
   RelayoutRequest();
 }
 
@@ -662,41 +710,45 @@ float TableView::GetRelativeWidth( unsigned int columnIndex ) const
   return mColumnData[ columnIndex ].fillRatio;
 }
 
-void TableView::CalculateRowColumnData()
-{
-  // Calculate the relative sizes
-  if( mRowColumnDirty )
-  {
-    ComputeRelativeSizes( mRowData );
-    ComputeRelativeSizes( mColumnData );
-
-    mRowColumnDirty = false;
-  }
-}
-
 void TableView::OnCalculateRelayoutSize( Dimension::Type dimension )
 {
-  CalculateRowColumnData();
-
-  if( dimension & Dimension::WIDTH )
+  if( (dimension & Dimension::WIDTH) && mColumnDirty )
   {
-    CalculateFixedSizes( mColumnData, Dimension::WIDTH );
+    /*
+     * FIXED and FIT have size in pixel
+     * Nothing to do with FIXED, as its value is assigned by user and will not get changed
+     *
+     * Need to update the size for FIT column here
+     */
+    CalculateFitSizes( mColumnData, Dimension::WIDTH );
+
+    /* RELATIVE and FILL have size in ratio
+     * Their size in pixel is not available until we get the negotiated size for the whole table
+     * Nothing to do with RELATIVE, as its ratio is assigned by user and will not get changed
+     *
+     * Need to update the ratio for FILL column here
+     */
+    CalculateFillSizes( mColumnData );
+
     mFixedTotals.width = CalculateTotalFixedSize( mColumnData );
   }
 
-  if( dimension & Dimension::HEIGHT )
+  if( (dimension & Dimension::HEIGHT) && mRowDirty )
   {
-    CalculateFixedSizes( mRowData, Dimension::HEIGHT );
+    // refer to the comment above
+    CalculateFitSizes( mRowData, Dimension::HEIGHT );
+
+    // refer to the comment above
+    CalculateFillSizes( mRowData );
+
     mFixedTotals.height = CalculateTotalFixedSize( mRowData );
   }
 }
 
 void TableView::OnLayoutNegotiated( float size, Dimension::Type dimension )
 {
-  CalculateRowColumnData();
-
-  // Calculate the value of all relative sized rows and columns
-  if( dimension & Dimension::WIDTH )
+  // Update the column sizes
+  if( (dimension & Dimension::WIDTH) && mColumnDirty )
   {
     float remainingSize = size - mFixedTotals.width;
     if( remainingSize < 0.0f )
@@ -704,10 +756,24 @@ void TableView::OnLayoutNegotiated( float size, Dimension::Type dimension )
       remainingSize = 0.0f;
     }
 
-    CalculateRelativeSizes( mColumnData, remainingSize );
+    // update every column position in ColumnData array
+    float cumulatedWidth = 0.0f;
+    for( unsigned int column = 0, columnCount = mCellData.GetColumns(); column < columnCount; ++column )
+    {
+      if( mColumnData[ column ].sizePolicy == Toolkit::TableView::FILL ||  mColumnData[ column ].sizePolicy == Toolkit::TableView::RELATIVE)
+      {
+        mColumnData[ column ].size = mColumnData[ column ].fillRatio * remainingSize;
+      }
+
+      cumulatedWidth += mColumnData[ column ].size;
+      mColumnData[column].position = cumulatedWidth;
+    }
+
+    mColumnDirty = false;
   }
 
-  if( dimension & Dimension::HEIGHT )
+  // Update the row sizes
+  if( (dimension & Dimension::HEIGHT) && mRowDirty )
   {
     float remainingSize = size - mFixedTotals.height;
     if( remainingSize < 0.0f )
@@ -715,53 +781,86 @@ void TableView::OnLayoutNegotiated( float size, Dimension::Type dimension )
       remainingSize = 0.0f;
     }
 
-    CalculateRelativeSizes( mRowData, remainingSize );
+    // update every row position in RowData array
+    float cumulatedHeight = 0.0f;
+    for( unsigned int row = 0, rowCount = mCellData.GetRows(); row < rowCount; ++row )
+    {
+      if( mRowData[ row ].sizePolicy == Toolkit::TableView::FILL ||  mRowData[ row ].sizePolicy == Toolkit::TableView::RELATIVE)
+      {
+        mRowData[ row ].size = mRowData[ row ].fillRatio * remainingSize;
+      }
+
+      cumulatedHeight += mRowData[ row ].size;
+      mRowData[row].position = cumulatedHeight;
+    }
+
+    mRowDirty = false;
   }
 }
 
-void TableView::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void TableView::OnSizeSet( const Vector3& size )
 {
-  CalculateRowColumnData();
+  // If this table view is size negotiated by another actor or control, then the
+  // rows and columns must be recalculated or the new size will not take effect.
+  mRowDirty = mColumnDirty = true;
+  RelayoutRequest();
+}
 
+void TableView::OnRelayout( const Vector2& size, RelayoutContainer& container )
+{
   // Go through the layout data
-  float cumulatedHeight = 0.0f;
-
-  const unsigned int rowCount = mCellData.GetRows();
-  const unsigned int columnCount = mCellData.GetColumns();
-
-  for( unsigned int row = 0; row < rowCount; ++row )
+  for( unsigned int row = 0, rowCount = mCellData.GetRows(); row < rowCount; ++row )
   {
-    float cumulatedWidth = 0.0f;
-
-    for( unsigned int column = 0; column < columnCount; ++column )
+    for( unsigned int column = 0, columnCount = mCellData.GetColumns(); 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 );
 
         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 );
-      }
+        float left = column > 0 ? mColumnData[column-1].position : 0.f;
+        float right = mColumnData[column+position.columnSpan-1].position;
+        float top = row > 0 ? mRowData[row-1].position : 0.f;
+        float bottom = mRowData[row+position.rowSpan-1].position;
 
-      DALI_ASSERT_DEBUG( column < mColumnData.Size() );
-      cumulatedWidth += mColumnData[ column ].size;
-    }
+        if( cellData.horizontalAlignment == HorizontalAlignment::LEFT )
+        {
+          actor.SetX( left + mPadding.width + padding.left );
+        }
+        else if( cellData.horizontalAlignment ==  HorizontalAlignment::RIGHT )
+        {
+          actor.SetX( right - mPadding.width - padding.right - actor.GetRelayoutSize( Dimension::WIDTH ) );
+        }
+        else //if( cellData.horizontalAlignment ==  HorizontalAlignment::CENTER )
+        {
+          actor.SetX( (left + right + 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( top + mPadding.height + padding.top );
+        }
+        else if( cellData.verticalAlignment == VerticalAlignment::BOTTOM )
+        {
+          actor.SetY( bottom - mPadding.height - padding.bottom -  actor.GetRelayoutSize( Dimension::HEIGHT ) );
+        }
+        else //if( cellData.verticalAlignment = VerticalAlignment::CENTER )
+        {
+          actor.SetY( (top + bottom + padding.top - padding.bottom - actor.GetRelayoutSize( Dimension::HEIGHT )) * 0.5f );
+        }
+      }
+    }
   }
 }
 
@@ -786,17 +885,25 @@ void TableView::SetProperty( BaseObject* object, Property::Index index, const Pr
     {
       case Toolkit::TableView::Property::ROWS:
       {
-        if( value.Get<unsigned int>() != tableViewImpl.GetRows() )
+        int rows = 0;
+        if( value.Get( rows ) && rows >= 0 )
         {
-          tableViewImpl.Resize( value.Get<unsigned int>(), tableViewImpl.GetColumns() );
+          if( static_cast<unsigned int>(rows) != tableViewImpl.GetRows() )
+          {
+            tableViewImpl.Resize( rows, tableViewImpl.GetColumns() );
+          }
         }
         break;
       }
       case Toolkit::TableView::Property::COLUMNS:
       {
-        if( value.Get<unsigned int>() != tableViewImpl.GetColumns() )
+        int columns = 0;
+        if( value.Get( columns ) && columns >= 0 )
         {
-          tableViewImpl.Resize( tableViewImpl.GetRows(), value.Get<unsigned int>() );
+          if( static_cast<unsigned int>( columns ) != tableViewImpl.GetColumns() )
+          {
+            tableViewImpl.Resize( tableViewImpl.GetRows(), value.Get<int>() );
+          }
         }
         break;
       }
@@ -807,12 +914,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;
       }
     }
@@ -832,12 +939,12 @@ Property::Value TableView::GetProperty( BaseObject* object, Property::Index inde
     {
       case Toolkit::TableView::Property::ROWS:
       {
-        value = tableViewImpl.GetRows();
+        value = static_cast<int>( tableViewImpl.GetRows() );
         break;
       }
       case Toolkit::TableView::Property::COLUMNS:
       {
-        value = tableViewImpl.GetColumns();
+        value = static_cast<int>( tableViewImpl.GetColumns() );
         break;
       }
       case Toolkit::TableView::Property::CELL_PADDING:
@@ -861,35 +968,56 @@ Property::Value TableView::GetProperty( BaseObject* object, Property::Index inde
   return value;
 }
 
-void TableView::OnControlChildAdd( Actor& child )
+void TableView::OnChildAdd( Actor& child )
 {
+  Control::OnChildAdd( child );
+
   if( mLayoutingChild )
   {
     // we're in the middle of laying out children so no point doing anything here
     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<std::string >();
+    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<std::string >();
+    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<unsigned int>( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::ROW_SPAN_PROPERTY_NAME) ).Get<float>() );
+    cellPosition.rowSpan = static_cast<unsigned int>( child.GetProperty( child.GetPropertyIndex(ROW_SPAN_PROPERTY_NAME) ).Get<float>() );
   }
 
-  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<unsigned int>( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::COLUMN_SPAN_PROPERTY_NAME) ).Get<float>() );
+    cellPosition.columnSpan = static_cast<unsigned int>( child.GetProperty( child.GetPropertyIndex(COLUMN_SPAN_PROPERTY_NAME) ).Get<float>() );
   }
 
-  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 >();
+    Vector2 indices = child.GetProperty( child.GetPropertyIndex(CELL_INDEX_PROPERTY_NAME) ).Get<Vector2 >();
     cellPosition.rowIndex = static_cast<unsigned int>( indices.x );
     cellPosition.columnIndex = static_cast<unsigned int>( indices.y );
 
     AddChild( child, cellPosition );
+    SetCellAlignment(cellPosition, horizontalAlignment, verticalAlignment);
 
     // Do not continue
     return;
@@ -909,9 +1037,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;
       }
     }
@@ -926,10 +1057,13 @@ 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 )
+void TableView::OnChildRemove( Actor& child )
 {
   // dont process if we're in the middle of bigger operation like delete row, column or resize
   if( !mLayoutingChild )
@@ -940,13 +1074,16 @@ void TableView::OnControlChildRemove( Actor& child )
       RelayoutRequest();
     }
   }
+
+  Control::OnChildRemove( child );
 }
 
 TableView::TableView( unsigned int initialRows, unsigned int initialColumns )
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
+: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
   mCellData( initialRows, initialColumns ),
   mLayoutingChild( false ),
-  mRowColumnDirty( true )     // Force recalculation first time
+  mRowDirty( true ),     // Force recalculation first time
+  mColumnDirty( true )
 {
   SetKeyboardNavigationSupport( true );
   ResizeContainers( initialRows, initialColumns );
@@ -1048,29 +1185,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<Property::Map>();
-    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* childMapValue = childMap->Find( "value" );
+        if( policy && childMapValue )
         {
-          Toolkit::TableView::LayoutPolicy policy = Scripting::GetEnumeration< Toolkit::TableView::LayoutPolicy >( item.GetValue("policy").Get<std::string>().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<float>() );
-          }
-          else if( policy == Toolkit::TableView::RELATIVE )
-          {
-            (tableViewImpl.*funcRelative)( rowIndex, item.GetValue("value").Get<float>() );
+            if( policy == Toolkit::TableView::FIXED  )
+            {
+              (tableViewImpl.*funcFixed)( index, childMapValue->Get<float>() );
+            }
+            else if( policy == Toolkit::TableView::RELATIVE )
+            {
+              (tableViewImpl.*funcRelative)( index, childMapValue->Get<float>() );
+            }
+            else if( policy == Toolkit::TableView::FIT )
+            {
+              (tableViewImpl.*funcFit)( index );
+            }
+            // do nothing for FILL policy
           }
         }
       }
@@ -1094,49 +1248,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;
   }
 }
 
@@ -1239,76 +1400,44 @@ Vector3 TableView::GetNaturalSize()
 
 float TableView::CalculateChildSize( const Actor& child, Dimension::Type dimension )
 {
-  CalculateRowColumnData();
-
-  const unsigned int rowCount = mCellData.GetRows();
-  const unsigned int columnCount = mCellData.GetColumns();
-
-  for( unsigned int row = 0; row < rowCount; ++row )
+  Toolkit::TableView::CellPosition position;
+  if( FindChildPosition( child, position) )
   {
-    for( unsigned int column = 0; column < columnCount; ++column )
+    switch( dimension )
     {
-      // check if this cell has an actor
-      Actor& actor = mCellData[ row ][ column ].actor;
-
-      if( actor && ( actor == child ) )
+      case Dimension::WIDTH:
       {
-        const Toolkit::TableView::CellPosition position = mCellData[ row ][ column ].position;
+        float cellSize = 0.0f;
+        cellSize = mColumnData[position.columnIndex+position.columnSpan-1].position
+                 - (position.columnIndex > 0 ? mColumnData[position.columnIndex-1].position : 0.f)
+                 - mPadding.width * 2.0f;
 
-        // 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.
-        if ( ( position.rowIndex == row ) && ( position.columnIndex == column ) )
+        if( cellSize < 0.0f )
         {
-          switch( dimension )
-          {
-            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;
-              }
-
-              // Apply padding
-              cellSize -= mPadding.width * 2.0f;
-              if( cellSize < 0.0f )
-              {
-                cellSize = 0.0f;
-              }
-
-              return cellSize;
-            }
+          cellSize = 0.0f;
+        }
 
-            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;
-              if( cellSize < 0.0f )
-              {
-                cellSize = 0.0f;
-              }
-
-              return cellSize;
-            }
+        return cellSize;
+      }
 
-            default:
-            {
-              return 0.0f;
-            }
-          }
+      case Dimension::HEIGHT:
+      {
+        float cellSize = 0.0f;
+
+        cellSize = mRowData[position.rowIndex+position.rowSpan-1].position
+                 - (position.rowIndex > 0 ? mRowData[position.rowIndex-1].position : 0.f)
+                 - mPadding.height * 2.0f;
+
+        if( cellSize < 0.0f )
+        {
+          cellSize = 0.0f;
         }
+
+        return cellSize;
+      }
+      default:
+      {
+        return 0.0f;
       }
     }
   }
@@ -1347,7 +1476,7 @@ void TableView::SetCellAlignment( Toolkit::TableView::CellPosition position, Hor
   data.verticalAlignment = vertical;
 }
 
-void TableView::ComputeRelativeSizes( RowColumnArray& data )
+void TableView::CalculateFillSizes( RowColumnArray& data )
 {
   // First pass: Count number of fill entries and calculate used relative space
   Dali::Vector< RowColumnData* > fillData;
@@ -1359,16 +1488,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 );
     }
   }
 
@@ -1402,8 +1528,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;
@@ -1440,7 +1567,7 @@ Vector2 TableView::GetCellPadding( Dimension::Type dimension )
   return Vector2();
 }
 
-void TableView::CalculateFixedSizes( RowColumnArray& data, Dimension::Type dimension )
+void TableView::CalculateFitSizes( RowColumnArray& data, Dimension::Type dimension )
 {
   Vector2 cellPadding = GetCellPadding( dimension );
 
@@ -1450,7 +1577,7 @@ void TableView::CalculateFixedSizes( RowColumnArray& data, Dimension::Type dimen
   {
     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;
@@ -1480,26 +1607,11 @@ void TableView::CalculateFixedSizes( RowColumnArray& data, Dimension::Type dimen
   }
 }
 
-void TableView::CalculateRelativeSizes( RowColumnArray& data, float size )
-{
-  const unsigned int dataCount = data.Size();
-
-  for( unsigned int i = 0; i < dataCount; ++i )
-  {
-    RowColumnData& dataInstance = data[ i ];
-
-    if( dataInstance.sizePolicy == FILL )
-    {
-      dataInstance.size = dataInstance.fillRatio * size;
-    }
-  }
-}
-
 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;
     }