dali-toolkit/internal/controls/table-view/table-view-impl.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/table-view/table-view-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <sstream>
  23 #include <dali/public-api/object/ref-object.h>
  24 #include <dali/public-api/object/type-registry.h>
  25 #include <dali/public-api/object/type-registry-helper.h>
  26 #include <dali/devel-api/scripting/scripting.h>
  27 #include <dali/public-api/size-negotiation/relayout-container.h>
  28 #include <dali/integration-api/debug.h>
  29
  30 using namespace Dali;
  31
  32 namespace
  33 {
  34 /**
  35  * @brief Should the tableview fit around the given actor
  36  *
  37  * @param[in] actor The child actor to test against
  38  * @param[dimension] The dimension to test against
  39  */
  40 bool FitToChild( Actor actor, Dimension::Type dimension )
  41 {
  42   return actor.GetResizePolicy( dimension ) != ResizePolicy::FILL_TO_PARENT && actor.GetRelayoutSize( dimension ) > 0.0f;
  43 }
  44
  45 #if defined(DEBUG_ENABLED)
  46 // debugging support, very useful when new features are added or bugs are hunted down
  47 // currently not called from code so compiler will optimize these away, kept here for future debugging
  48
  49 #define TABLEVIEW_TAG "DALI Toolkit::TableView "
  50 #define TV_LOG(fmt, args...) Debug::LogMessage(Debug::DebugInfo, TABLEVIEW_TAG fmt, ## args)
  51 //#define TABLEVIEW_DEBUG 1
  52
  53 #if defined(TABLEVIEW_DEBUG)
  54 void PrintArray( Array2d<Dali::Toolkit::Internal::TableView::CellData>& array )
  55 {
  56   TV_LOG( "Array2d<CellData> size [%d,%d] \n", array.GetRows(), array.GetColumns() );
  57   // print values
  58   for( unsigned int i = 0; i < array.GetRows(); ++i )
  59   {
  60     for( unsigned int j = 0; j < array.GetColumns(); ++j )
  61     {
  62       Dali::Toolkit::Internal::TableView::CellData data = array[i][j];
  63       char actor = ' ';
  64       std::string actorName;
  65       if( data.actor )
  66       {
  67         actor = 'A';
  68         actorName = data.actor.GetName();
  69       }
  70       TV_LOG("Array[%d,%d]=%c %s %d,%d,%d,%d  ", i, j, actor, actorName.c_str(),
  71           data.position.rowIndex, data.position.columnIndex,
  72           data.position.rowSpan, data.position.columnSpan );
  73     }
  74     TV_LOG( "\n" );
  75   }
  76 }
  77
  78 // debugging support, very useful when new features are added or bugs are hunted down
  79 // currently not called from code so compiler will optimize these away, kept here for future debugging
  80 void PrintArray( Array2d<Size>& array )
  81 {
  82   TV_LOG( "Array2d<Size> size [%d,%d] \n", array.GetRows(), array.GetColumns() );
  83   // print values
  84   for( unsigned int i = 0; i < array.GetRows(); ++i )
  85   {
  86     for( unsigned int j = 0; j < array.GetColumns(); ++j )
  87     {
  88       TV_LOG( "Array[%d,%d]=%.2f,%.2f ", i, j, array[i][j].width, array[i][j].height );
  89     }
  90     TV_LOG( "\n" );
  91   }
  92 }
  93 // debugging support, very useful when new features are added or bugs are hunted down
  94 // currently not called from code so compiler will optimize these away, kept here for future debugging
  95 void PrintVector( std::vector<float>& array )
  96 {
  97   TV_LOG( "vector, size [%d]\n", array.size() );
  98   // print values
  99   for( unsigned int i = 0; i < array.size(); ++i )
 100   {
 101     TV_LOG( "vector[%d]=%.2f ", i, array[i] );
 102   }
 103   TV_LOG( "\n" );
 104 }
 105 #endif // defined(TABLEVIEW_DEBUG)
 106 #endif // defined(DEBUG_ENABLED)
 107
 108 } // namespace
 109
 110 namespace Dali
 111 {
 112
 113 namespace Toolkit
 114 {
 115
 116 namespace Internal
 117 {
 118
 119 namespace
 120 {
 121
 122 // Type registration
 123 BaseHandle Create()
 124 {
 125   return Toolkit::TableView::New( 0, 0 );
 126 }
 127
 128 // Setup properties, signals and actions using the type-registry.
 129 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::TableView, Toolkit::Control, Create );
 130
 131 DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "rows",           INTEGER, ROWS           )
 132 DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "columns",        INTEGER, COLUMNS        )
 133 DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "cellPadding",    VECTOR2, CELL_PADDING   )
 134 DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutRows",     MAP,     LAYOUT_ROWS    )
 135 DALI_PROPERTY_REGISTRATION( Toolkit, TableView, "layoutColumns",  MAP,     LAYOUT_COLUMNS )
 136 DALI_CHILD_PROPERTY_REGISTRATION( Toolkit, TableView, "cellIndex",                VECTOR2, CELL_INDEX                )
 137 DALI_CHILD_PROPERTY_REGISTRATION( Toolkit, TableView, "rowSpan",                  FLOAT,   ROW_SPAN                  )
 138 DALI_CHILD_PROPERTY_REGISTRATION( Toolkit, TableView, "columnSpan",               FLOAT,   COLUMN_SPAN               )
 139 DALI_CHILD_PROPERTY_REGISTRATION( Toolkit, TableView, "cellHorizontalAlignment",  STRING,  CELL_HORIZONTAL_ALIGNMENT )
 140 DALI_CHILD_PROPERTY_REGISTRATION( Toolkit, TableView, "cellVerticalAlignment",    STRING,  CELL_VERTICAL_ALIGNMENT   )
 141
 142 DALI_TYPE_REGISTRATION_END()
 143
 144 const Scripting::StringEnum LAYOUT_POLICY_STRING_TABLE[] =
 145 {
 146  { "fixed",    Toolkit::TableView::FIXED    },
 147  { "relative", Toolkit::TableView::RELATIVE },
 148  { "fill",     Toolkit::TableView::FILL     },
 149  { "fit",      Toolkit::TableView::FIT      }
 150 };
 151 const unsigned int LAYOUT_POLICY_STRING_TABLE_COUNT = sizeof(LAYOUT_POLICY_STRING_TABLE) / sizeof( LAYOUT_POLICY_STRING_TABLE[0] );
 152
 153 const Scripting::StringEnum HORIZONTAL_ALIGNMENT_STRING_TABLE[] =
 154 {
 155   {"left",   HorizontalAlignment::LEFT},
 156   {"center", HorizontalAlignment::CENTER},
 157   {"right",  HorizontalAlignment::RIGHT}
 158 };
 159 const unsigned int HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof(HORIZONTAL_ALIGNMENT_STRING_TABLE) / sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE[0] );
 160
 161 const Scripting::StringEnum VERTICAL_ALIGNMENT_STRING_TABLE[] =
 162 {
 163   {"top",    VerticalAlignment::TOP},
 164   {"center", VerticalAlignment::CENTER},
 165   {"bottom", VerticalAlignment::BOTTOM}
 166 };
 167 const unsigned int VERTICAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof(VERTICAL_ALIGNMENT_STRING_TABLE) / sizeof( VERTICAL_ALIGNMENT_STRING_TABLE[0] );
 168
 169 } // Unnamed namespace
 170
 171 Toolkit::TableView TableView::New( unsigned int initialRows, unsigned int initialColumns )
 172 {
 173   // Create the implementation, temporarily owned by this handle on stack
 174   IntrusivePtr< TableView > impl = new TableView( initialRows, initialColumns );
 175
 176   // Pass ownership to CustomActor handle
 177   Toolkit::TableView handle( *impl );
 178
 179   // Second-phase init of the implementation
 180   // This can only be done after the CustomActor connection has been made...
 181   impl->Initialize();
 182
 183   return handle;
 184 }
 185
 186 bool TableView::AddChild( Actor& child, const Toolkit::TableView::CellPosition& position )
 187 {
 188   // check that the child is valid
 189   DALI_ASSERT_ALWAYS( child );
 190
 191   // if child is already parented, we adopt it
 192   child.Unparent();
 193
 194   // check if we need to expand our data array
 195   if( position.rowIndex >= mCellData.GetRows() )
 196   {
 197     // only adding new rows
 198     ResizeContainers( position.rowIndex + 1, mCellData.GetColumns() );
 199   }
 200
 201   if( position.columnIndex >= mCellData.GetColumns() )
 202   {
 203     // only adding new columns
 204     ResizeContainers( mCellData.GetRows(), position.columnIndex + 1 );
 205   }
 206
 207   // check if there already is something in this cell
 208   if( mCellData[ position.rowIndex ][ position.columnIndex ].actor )
 209   {
 210     return false; // cannot share a cell, it would complicate all logic and not bring much benefit
 211   }
 212
 213   RelayoutingLock lock( *this );
 214   // adopt the child
 215   Self().Add( child );
 216
 217   // if child spans multiple rows of columns
 218   if( ( position.rowSpan > 1 ) && ( position.rowIndex + position.rowSpan > mCellData.GetRows() ) )
 219   {
 220     // increase table size for the full span, only increasing rows
 221     ResizeContainers( position.rowIndex + position.rowSpan, mCellData.GetColumns() );
 222   }
 223
 224   if( ( position.columnSpan > 1 ) && ( position.columnIndex + position.columnSpan > mCellData.GetColumns() ) )
 225   {
 226     // increase table size for the full span, only increasing columns
 227     ResizeContainers( mCellData.GetRows(), position.columnIndex + position.columnSpan );
 228   }
 229
 230   // Fill in all cells that need the data
 231   CellData data;
 232   data.actor = child;
 233   data.position = position;
 234
 235   for( unsigned int row = position.rowIndex; row < ( position.rowIndex + position.rowSpan ); ++row )
 236   {
 237     // store same information to all cells, this way we can identify
 238     // if a cell is the prime location of an actor or a spanned one
 239     for( unsigned int column = position.columnIndex; column < ( position.columnIndex + position.columnSpan ); ++column )
 240     {
 241       // store same information to all cells, this way we can identify
 242       // if a cell is the prime location of an actor or a spanned one
 243       mCellData[ row ][ column ] = data;
 244     }
 245   }
 246
 247   // Relayout the whole table
 248   if( mRowData[position.rowIndex].sizePolicy == Toolkit::TableView::FIT && position.rowSpan == 1 )
 249   {
 250     mRowDirty = true;
 251   }
 252   if( mColumnData[position.columnIndex].sizePolicy == Toolkit::TableView::FIT && position.columnSpan == 1 )
 253   {
 254     mColumnDirty = true;
 255   }
 256
 257   RelayoutRequest();
 258
 259   return true;    // Addition successful
 260 }
 261
 262 Actor TableView::GetChildAt( const Toolkit::TableView::CellPosition& position )
 263 {
 264   if( ( position.rowIndex < mCellData.GetRows() ) && ( position.columnIndex < mCellData.GetColumns() ) )
 265   {
 266     return mCellData[ position.rowIndex ][ position.columnIndex ].actor;
 267   }
 268
 269   // Return an empty handle
 270   return Actor();
 271 }
 272
 273 Actor TableView::RemoveChildAt( const Toolkit::TableView::CellPosition& position )
 274 {
 275   // get the child handle
 276   Actor child = GetChildAt( position );
 277   // if no real actor there, nothing else to be done
 278   if( child )
 279   {
 280     RelayoutingLock lock( *this );
 281     // Remove the child, this will trigger a call to OnChildRemove
 282     Self().Remove( child );
 283
 284     // relayout the table only if instances were found
 285     if( RemoveAllInstances( child ) )
 286     {
 287       if( mRowData[position.rowIndex].sizePolicy == Toolkit::TableView::FIT )
 288       {
 289         mRowDirty = true;
 290       }
 291       if( mColumnData[position.columnIndex].sizePolicy == Toolkit::TableView::FIT )
 292       {
 293         mColumnDirty = true;
 294       }
 295       RelayoutRequest();
 296     }
 297   }
 298   // return the child back to caller
 299   return child;
 300 }
 301
 302 bool TableView::FindChildPosition( const Actor& child, Toolkit::TableView::CellPosition& positionOut )
 303 {
 304   // Only find valid child actors
 305   if( child )
 306   {
 307     // Walk through the layout data
 308     const unsigned int rowCount = mCellData.GetRows();
 309     const unsigned int columnCount = mCellData.GetColumns();
 310
 311     for( unsigned int row = 0; row < rowCount; ++row )
 312     {
 313       for( unsigned int column = 0; column < columnCount; ++column )
 314       {
 315         if( mCellData[ row ][ column ].actor == child )
 316         {
 317           positionOut = mCellData[ row ][ column ].position;
 318           return true;
 319         }
 320       }
 321     }
 322   }
 323
 324   return false;
 325 }
 326
 327 void TableView::InsertRow( unsigned int rowIndex )
 328 {
 329   RelayoutingLock lock( *this );
 330
 331   mCellData.InsertRow( rowIndex );
 332
 333   // Need to update the cell infos for the items that moved
 334   const unsigned int rowCount = mCellData.GetRows();
 335   const unsigned int columnCount = mCellData.GetColumns();
 336
 337   for( unsigned int row = 0; row < rowCount; ++row )
 338   {
 339     for( unsigned int column = 0; column < columnCount; ++column )
 340     {
 341       Toolkit::TableView::CellPosition& position = mCellData[ row ][ column ].position;
 342
 343       // If cell is spanning and above and spans to inserted row
 344       if( ( position.rowSpan > 1 ) && ( position.rowIndex <= rowIndex ) &&
 345           ( position.rowIndex + position.rowSpan > rowIndex ) )
 346       {
 347         // Increment span
 348         position.rowSpan++;
 349
 350         // Copy cell to occupy the new column
 351         mCellData[ rowIndex ][ column ] = mCellData[ row ][ column ];
 352       }
 353       else if( row > rowIndex )   // If below of inserted row, increase row index
 354       {
 355         // Increment index
 356         position.rowIndex++;
 357       }
 358     }
 359   }
 360
 361   // Expand row data array
 362   mRowData.Insert( mRowData.Begin() + rowIndex, RowColumnData() );
 363
 364   // Sizes may have changed, so relayout
 365   mRowDirty = true;
 366   RelayoutRequest();
 367 }
 368
 369 void TableView::DeleteRow( unsigned int rowIndex )
 370 {
 371   std::vector< Actor > ignored;
 372   DeleteRow( rowIndex, ignored );
 373 }
 374
 375 void TableView::DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed )
 376 {
 377   RelayoutingLock lock( *this );
 378
 379   // Delete the row
 380   std::vector< CellData > lost;
 381   mCellData.DeleteRow( rowIndex, lost );
 382
 383   // Need to update the cell infos for the items that moved
 384   const unsigned int rowCount = mCellData.GetRows();
 385   const unsigned int columnCount = mCellData.GetColumns();
 386
 387   for( unsigned int row = 0; row < rowCount; ++row )
 388   {
 389     for( unsigned int column = 0; column < columnCount; ++column )
 390     {
 391       Toolkit::TableView::CellPosition& position = mCellData[ row ][ column ].position;
 392
 393       // If cell is spanning and above and spans to deleted row
 394       if( ( position.rowSpan > 1 ) && ( position.rowIndex <= rowIndex ) &&
 395           ( position.rowIndex + position.rowSpan > rowIndex ) )
 396       {
 397         // Decrement span
 398         if( position.rowSpan > 1 )
 399         {
 400           position.rowSpan--;
 401         }
 402       }
 403       else if( row >= rowIndex )    // If below of or at the inserted row, decrease row index
 404       {
 405         // Decrement index
 406         if( position.rowIndex > 0 )
 407         {
 408           position.rowIndex--;
 409         }
 410       }
 411     }
 412   }
 413
 414   // 1 row removed, 0 columns
 415   RemoveAndGetLostActors( lost, removed, 1u, 0u );
 416
 417   // Contract row data array
 418   mRowData.Erase( mRowData.Begin() + rowIndex );
 419
 420   // Sizes may have changed, so relayout
 421   mRowDirty = true;
 422   // it is possible that the deletion of row leads to remove of child which might further lead to the change of FIT column
 423   mColumnDirty = true;
 424
 425   RelayoutRequest();
 426 }
 427
 428 void TableView::InsertColumn( unsigned int columnIndex )
 429 {
 430   RelayoutingLock lock( *this );
 431
 432   // Insert the new column
 433   mCellData.InsertColumn( columnIndex );
 434
 435   // Need to update the cell infos for the items that moved
 436   const unsigned int rowCount = mCellData.GetRows();
 437   const unsigned int columnCount = mCellData.GetColumns();
 438
 439   for( unsigned int row = 0; row < rowCount; ++row )
 440   {
 441     for( unsigned int column = 0; column < columnCount; ++column )
 442     {
 443       Toolkit::TableView::CellPosition& position = mCellData[ row ][ column ].position;
 444
 445       // If cell is spanning and left side and spans to inserted column
 446       if( ( position.columnSpan > 1 ) && ( position.columnIndex <= columnIndex ) &&
 447           ( position.columnIndex + position.columnSpan > columnIndex ) )
 448       {
 449         // Increment span
 450         position.columnSpan++;
 451
 452         // Copy cell to occupy the new column
 453         mCellData[ row ][ columnIndex ] = mCellData[ row ][ column ];
 454       }
 455       else if( column > columnIndex )   // If on the right side of inserted column, increase column index
 456       {
 457         // Increment index
 458         position.columnIndex++;
 459       }
 460     }
 461   }
 462
 463   // Expand column data array
 464   mColumnData.Insert( mColumnData.Begin() + columnIndex, RowColumnData() );
 465
 466   // Sizes may have changed so relayout
 467   mColumnDirty = true;
 468   RelayoutRequest();
 469 }
 470
 471 void TableView::DeleteColumn( unsigned int columnIndex )
 472 {
 473   std::vector< Actor > ignored;
 474   DeleteColumn( columnIndex, ignored );
 475 }
 476
 477 void TableView::DeleteColumn( unsigned int columnIndex, std::vector<Actor>& removed )
 478 {
 479   RelayoutingLock lock( *this );
 480
 481   // Remove the column
 482   std::vector< CellData > lost;
 483   mCellData.DeleteColumn( columnIndex, lost );
 484
 485   // Need to update the cell infos for the items that moved
 486   const unsigned int rowCount = mCellData.GetRows();
 487   const unsigned int columnCount = mCellData.GetColumns();
 488
 489   for( unsigned int row = 0; row < rowCount; ++row )
 490   {
 491     for( unsigned int column = 0; column < columnCount; ++column )
 492     {
 493       Toolkit::TableView::CellPosition& position = mCellData[ row ][ column ].position;
 494
 495       // If cell is spanning and left side and spans to inserted column
 496       if( ( position.columnSpan > 1 ) && ( position.columnIndex <= columnIndex ) &&
 497           ( position.columnIndex + position.columnSpan > columnIndex ) )
 498       {
 499         // Decrement span
 500         if( position.columnSpan > 1 )
 501         {
 502           position.columnSpan--;
 503         }
 504       }
 505       else if( column >= columnIndex )    // If on the right side of or at the inserted column, decrease column index
 506       {
 507         // Decrement index
 508         if( position.columnIndex > 0 )
 509         {
 510           position.columnIndex--;
 511         }
 512       }
 513     }
 514   }
 515
 516   // 0 rows, 1 column removed
 517   RemoveAndGetLostActors( lost, removed, 0u, 1u );
 518
 519   // Contract column data array
 520   mColumnData.Erase( mColumnData.Begin() + columnIndex );
 521
 522   // Size may have changed so relayout
 523   mColumnDirty = true;
 524   // it is possible that the deletion of column leads to remove of child which might further lead to the change of FIT row
 525   mRowDirty = true;
 526
 527   RelayoutRequest();
 528 }
 529
 530 void TableView::Resize( unsigned int rows, unsigned int columns )
 531 {
 532   std::vector< Actor > ignored;
 533   Resize( rows, columns, ignored );
 534 }
 535
 536 void TableView::Resize( unsigned int rows, unsigned int columns, std::vector<Actor>& removed )
 537 {
 538   RelayoutingLock lock( *this );
 539
 540   unsigned int oldRows = GetRows();
 541   unsigned int oldColumns = GetColumns();
 542
 543   // Resize data array
 544   std::vector< CellData > lost;
 545   ResizeContainers( rows, columns, lost );
 546
 547   // Calculate if we lost rows
 548   unsigned int rowsRemoved = 0;
 549   unsigned int newRows = GetRows();
 550
 551   if( oldRows < newRows )
 552   {
 553     rowsRemoved = newRows - oldRows;
 554   }
 555
 556   // Calculate if we lost columns
 557   unsigned int columnsRemoved = 0;
 558   unsigned int newColumns = GetColumns();
 559   if( oldColumns < newColumns )
 560   {
 561     rowsRemoved = newColumns - oldColumns;
 562   }
 563
 564   RemoveAndGetLostActors( lost, removed, rowsRemoved, columnsRemoved );
 565
 566   // Sizes may have changed so request a relayout
 567   mRowDirty = true;
 568   mColumnDirty = true;
 569   RelayoutRequest();
 570 }
 571
 572 void TableView::SetCellPadding( Size padding )
 573 {
 574   // If padding really changed
 575   if( padding != mPadding )
 576   {
 577     mPadding = padding;
 578
 579     RelayoutRequest();
 580   }
 581 }
 582
 583 Size TableView::GetCellPadding()
 584 {
 585   return mPadding;
 586 }
 587
 588 void TableView::SetFitHeight( unsigned int rowIndex )
 589 {
 590   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 591
 592   if( mRowData[ rowIndex ].sizePolicy != Toolkit::TableView::FIT )
 593   {
 594     mRowData[ rowIndex ].sizePolicy = Toolkit::TableView::FIT;
 595
 596     mRowDirty = true;
 597     RelayoutRequest();
 598   }
 599 }
 600
 601 bool TableView::IsFitHeight( unsigned int rowIndex ) const
 602 {
 603   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 604
 605   return mRowData[ rowIndex ].sizePolicy == Toolkit::TableView::FIT;
 606 }
 607
 608 void TableView::SetFitWidth( unsigned int columnIndex )
 609 {
 610   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 611
 612   if( mColumnData[ columnIndex ].sizePolicy != Toolkit::TableView::FIT )
 613   {
 614     mColumnData[ columnIndex ].sizePolicy = Toolkit::TableView::FIT;
 615
 616     mColumnDirty = true;
 617     RelayoutRequest();
 618   }
 619 }
 620
 621 bool TableView::IsFitWidth( unsigned int columnIndex ) const
 622 {
 623   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 624
 625   return mColumnData[ columnIndex ].sizePolicy == Toolkit::TableView::FIT;
 626 }
 627
 628 void TableView::SetFixedHeight( unsigned int rowIndex, float height )
 629 {
 630   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 631
 632   RowColumnData& data = mRowData[ rowIndex ];
 633   data.size = height;
 634   data.sizePolicy = Toolkit::TableView::FIXED;
 635
 636   mRowDirty = true;
 637   RelayoutRequest();
 638 }
 639
 640 float TableView::GetFixedHeight( unsigned int rowIndex ) const
 641 {
 642   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 643
 644   return mRowData[ rowIndex ].size;
 645 }
 646
 647 void TableView::SetFixedWidth( unsigned int columnIndex, float width )
 648 {
 649   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 650
 651   RowColumnData& data = mColumnData[ columnIndex ];
 652   data.size = width;
 653   data.sizePolicy = Toolkit::TableView::FIXED;
 654
 655   mColumnDirty = true;
 656   RelayoutRequest();
 657 }
 658
 659 float TableView::GetFixedWidth( unsigned int columnIndex ) const
 660 {
 661   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 662
 663   return mColumnData[ columnIndex ].size;
 664 }
 665
 666 void TableView::SetRelativeHeight( unsigned int rowIndex, float heightPercentage )
 667 {
 668   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 669
 670   RowColumnData& data = mRowData[ rowIndex ];
 671   data.fillRatio = heightPercentage;
 672   data.sizePolicy = Toolkit::TableView::RELATIVE;
 673
 674   mRowDirty = true;
 675   RelayoutRequest();
 676 }
 677
 678 float TableView::GetRelativeHeight( unsigned int rowIndex ) const
 679 {
 680   DALI_ASSERT_ALWAYS( rowIndex < mRowData.Size() );
 681
 682   return mRowData[ rowIndex ].fillRatio;
 683 }
 684
 685 void TableView::SetRelativeWidth( unsigned int columnIndex, float widthPercentage )
 686 {
 687   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 688
 689   RowColumnData& data = mColumnData[ columnIndex ];
 690   data.fillRatio = widthPercentage;
 691   data.sizePolicy = Toolkit::TableView::RELATIVE;
 692
 693   mColumnDirty = true;
 694   RelayoutRequest();
 695 }
 696
 697 float TableView::GetRelativeWidth( unsigned int columnIndex ) const
 698 {
 699   DALI_ASSERT_ALWAYS( columnIndex < mColumnData.Size() );
 700
 701   return mColumnData[ columnIndex ].fillRatio;
 702 }
 703
 704 void TableView::OnCalculateRelayoutSize( Dimension::Type dimension )
 705 {
 706   if( (dimension & Dimension::WIDTH) && mColumnDirty )
 707   {
 708     /*
 709      * FIXED and FIT have size in pixel
 710      * Nothing to do with FIXED, as its value is assigned by user and will not get changed
 711      *
 712      * Need to update the size for FIT column here
 713      */
 714     CalculateFitSizes( mColumnData, Dimension::WIDTH );
 715
 716     /* RELATIVE and FILL have size in ratio
 717      * Their size in pixel is not available until we get the negotiated size for the whole table
 718      * Nothing to do with RELATIVE, as its ratio is assigned by user and will not get changed
 719      *
 720      * Need to update the ratio for FILL column here
 721      */
 722     CalculateFillSizes( mColumnData );
 723
 724     mFixedTotals.width = CalculateTotalFixedSize( mColumnData );
 725   }
 726
 727   if( (dimension & Dimension::HEIGHT) && mRowDirty )
 728   {
 729     // refer to the comment above
 730     CalculateFitSizes( mRowData, Dimension::HEIGHT );
 731
 732     // refer to the comment above
 733     CalculateFillSizes( mRowData );
 734
 735     mFixedTotals.height = CalculateTotalFixedSize( mRowData );
 736   }
 737 }
 738
 739 void TableView::OnLayoutNegotiated( float size, Dimension::Type dimension )
 740 {
 741   // Update the column sizes
 742   if( (dimension & Dimension::WIDTH) && mColumnDirty )
 743   {
 744     float remainingSize = size - mFixedTotals.width;
 745     if( remainingSize < 0.0f )
 746     {
 747       remainingSize = 0.0f;
 748     }
 749
 750     // update every column position in ColumnData array
 751     float cumulatedWidth = 0.0f;
 752     for( unsigned int column = 0, columnCount = mCellData.GetColumns(); column < columnCount; ++column )
 753     {
 754       if( mColumnData[ column ].sizePolicy == Toolkit::TableView::FILL ||  mColumnData[ column ].sizePolicy == Toolkit::TableView::RELATIVE)
 755       {
 756         mColumnData[ column ].size = mColumnData[ column ].fillRatio * remainingSize;
 757       }
 758
 759       cumulatedWidth += mColumnData[ column ].size;
 760       mColumnData[column].position = cumulatedWidth;
 761     }
 762
 763     mColumnDirty = false;
 764   }
 765
 766   // Update the row sizes
 767   if( (dimension & Dimension::HEIGHT) && mRowDirty )
 768   {
 769     float remainingSize = size - mFixedTotals.height;
 770     if( remainingSize < 0.0f )
 771     {
 772       remainingSize = 0.0f;
 773     }
 774
 775     // update every row position in RowData array
 776     float cumulatedHeight = 0.0f;
 777     for( unsigned int row = 0, rowCount = mCellData.GetRows(); row < rowCount; ++row )
 778     {
 779       if( mRowData[ row ].sizePolicy == Toolkit::TableView::FILL ||  mRowData[ row ].sizePolicy == Toolkit::TableView::RELATIVE)
 780       {
 781         mRowData[ row ].size = mRowData[ row ].fillRatio * remainingSize;
 782       }
 783
 784       cumulatedHeight += mRowData[ row ].size;
 785       mRowData[row].position = cumulatedHeight;
 786     }
 787
 788     mRowDirty = false;
 789   }
 790 }
 791
 792 void TableView::OnSizeSet( const Vector3& size )
 793 {
 794   // If this table view is size negotiated by another actor or control, then the
 795   // rows and columns must be recalculated or the new size will not take effect.
 796   mRowDirty = mColumnDirty = true;
 797   RelayoutRequest();
 798
 799   Control::OnSizeSet( size );
 800 }
 801
 802 void TableView::OnRelayout( const Vector2& size, RelayoutContainer& container )
 803 {
 804   // Go through the layout data
 805   for( unsigned int row = 0, rowCount = mCellData.GetRows(); row < rowCount; ++row )
 806   {
 807     for( unsigned int column = 0, columnCount = mCellData.GetColumns(); column < columnCount; ++column )
 808     {
 809       CellData& cellData= mCellData[ row ][ column ];
 810       Actor& actor = cellData.actor;
 811       const Toolkit::TableView::CellPosition position = cellData.position;
 812
 813       // If there is an actor and this is the main cell of the actor.
 814       // An actor can be in multiple cells if its row or column span is more than 1.
 815       // We however must lay out each actor only once.
 816       if( actor &&  position.rowIndex == row && position.columnIndex == column )
 817       {
 818         // Anchor actor to top left of the cell
 819         actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 820         actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 821
 822         Padding padding;
 823         actor.GetPadding( padding );
 824
 825         float left = column > 0 ? mColumnData[column-1].position : 0.f;
 826         float right = mColumnData[column+position.columnSpan-1].position;
 827         float top = row > 0 ? mRowData[row-1].position : 0.f;
 828         float bottom = mRowData[row+position.rowSpan-1].position;
 829
 830         if( cellData.horizontalAlignment == HorizontalAlignment::LEFT )
 831         {
 832           actor.SetX( left + mPadding.width + padding.left );
 833         }
 834         else if( cellData.horizontalAlignment ==  HorizontalAlignment::RIGHT )
 835         {
 836           actor.SetX( right - mPadding.width - padding.right - actor.GetRelayoutSize( Dimension::WIDTH ) );
 837         }
 838         else //if( cellData.horizontalAlignment ==  HorizontalAlignment::CENTER )
 839         {
 840           actor.SetX( (left + right + padding.left - padding.right - actor.GetRelayoutSize( Dimension::WIDTH )) * 0.5f );
 841         }
 842
 843         if( cellData.verticalAlignment == VerticalAlignment::TOP )
 844         {
 845           actor.SetY( top + mPadding.height + padding.top );
 846         }
 847         else if( cellData.verticalAlignment == VerticalAlignment::BOTTOM )
 848         {
 849           actor.SetY( bottom - mPadding.height - padding.bottom -  actor.GetRelayoutSize( Dimension::HEIGHT ) );
 850         }
 851         else //if( cellData.verticalAlignment = VerticalAlignment::CENTER )
 852         {
 853           actor.SetY( (top + bottom + padding.top - padding.bottom - actor.GetRelayoutSize( Dimension::HEIGHT )) * 0.5f );
 854         }
 855       }
 856     }
 857   }
 858 }
 859
 860 unsigned int TableView::GetRows()
 861 {
 862   return mCellData.GetRows();
 863 }
 864
 865 unsigned int TableView::GetColumns()
 866 {
 867   return mCellData.GetColumns();
 868 }
 869
 870 void TableView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 871 {
 872   Toolkit::TableView tableView = Toolkit::TableView::DownCast( Dali::BaseHandle( object ) );
 873
 874   if( tableView )
 875   {
 876     TableView& tableViewImpl( GetImpl( tableView ) );
 877     switch( index )
 878     {
 879       case Toolkit::TableView::Property::ROWS:
 880       {
 881         int rows = 0;
 882         if( value.Get( rows ) && rows >= 0 )
 883         {
 884           if( static_cast<unsigned int>(rows) != tableViewImpl.GetRows() )
 885           {
 886             tableViewImpl.Resize( rows, tableViewImpl.GetColumns() );
 887           }
 888         }
 889         break;
 890       }
 891       case Toolkit::TableView::Property::COLUMNS:
 892       {
 893         int columns = 0;
 894         if( value.Get( columns ) && columns >= 0 )
 895         {
 896           if( static_cast<unsigned int>( columns ) != tableViewImpl.GetColumns() )
 897           {
 898             tableViewImpl.Resize( tableViewImpl.GetRows(), value.Get<int>() );
 899           }
 900         }
 901         break;
 902       }
 903       case Toolkit::TableView::Property::CELL_PADDING:
 904       {
 905         tableViewImpl.SetCellPadding( value.Get<Vector2>() );
 906         break;
 907       }
 908       case Toolkit::TableView::Property::LAYOUT_ROWS:
 909       {
 910         SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedHeight, &TableView::SetRelativeHeight, &TableView::SetFitHeight, value );
 911         break;
 912       }
 913       case Toolkit::TableView::Property::LAYOUT_COLUMNS:
 914       {
 915         SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedWidth, &TableView::SetRelativeWidth, &TableView::SetFitWidth, value );
 916         break;
 917       }
 918     }
 919   }
 920 }
 921
 922 Property::Value TableView::GetProperty( BaseObject* object, Property::Index index )
 923 {
 924   Property::Value value;
 925
 926   Toolkit::TableView tableView = Toolkit::TableView::DownCast( Dali::BaseHandle( object ) );
 927
 928   if( tableView )
 929   {
 930     TableView& tableViewImpl( GetImpl( tableView ) );
 931     switch( index )
 932     {
 933       case Toolkit::TableView::Property::ROWS:
 934       {
 935         value = static_cast<int>( tableViewImpl.GetRows() );
 936         break;
 937       }
 938       case Toolkit::TableView::Property::COLUMNS:
 939       {
 940         value = static_cast<int>( tableViewImpl.GetColumns() );
 941         break;
 942       }
 943       case Toolkit::TableView::Property::CELL_PADDING:
 944       {
 945         value = tableViewImpl.GetCellPadding();
 946         break;
 947       }
 948       case Toolkit::TableView::Property::LAYOUT_ROWS:
 949       {
 950         value = tableViewImpl.GetRowHeightsPropertyValue();
 951         break;
 952       }
 953       case Toolkit::TableView::Property::LAYOUT_COLUMNS:
 954       {
 955         value = tableViewImpl.GetColumnWidthsPropertyValue();
 956         break;
 957       }
 958     }
 959   }
 960
 961   return value;
 962 }
 963
 964 void TableView::OnChildAdd( Actor& child )
 965 {
 966   if( ! mLayoutingChild )
 967   {
 968     // Ensure we're not in the middle of laying out children
 969
 970     // Check child properties on actor to decide its position inside the table
 971     HorizontalAlignment::Type horizontalAlignment = HorizontalAlignment::LEFT;
 972     VerticalAlignment::Type verticalAlignment = VerticalAlignment::TOP;
 973
 974     if( child.GetPropertyType( Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT ) != Property::NONE )
 975     {
 976       std::string value = child.GetProperty( Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT ).Get<std::string >();
 977       Scripting::GetEnumeration< HorizontalAlignment::Type >( value.c_str(),
 978                                                               HORIZONTAL_ALIGNMENT_STRING_TABLE,
 979                                                               HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT,
 980                                                               horizontalAlignment );
 981     }
 982
 983     if( child.GetPropertyType( Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT ) != Property::NONE )
 984     {
 985       std::string value = child.GetProperty( Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT ).Get<std::string >();
 986       Scripting::GetEnumeration< VerticalAlignment::Type >( value.c_str(),
 987                                                             VERTICAL_ALIGNMENT_STRING_TABLE,
 988                                                             VERTICAL_ALIGNMENT_STRING_TABLE_COUNT,
 989                                                             verticalAlignment );
 990     }
 991
 992     Toolkit::TableView::CellPosition cellPosition;
 993     if( child.GetPropertyType( Toolkit::TableView::ChildProperty::ROW_SPAN ) != Property::NONE )
 994     {
 995       cellPosition.rowSpan = static_cast<unsigned int>( child.GetProperty( Toolkit::TableView::ChildProperty::ROW_SPAN ).Get<float>() );
 996     }
 997
 998     if( child.GetPropertyType( Toolkit::TableView::ChildProperty::COLUMN_SPAN ) != Property::NONE )
 999     {
1000       cellPosition.columnSpan = static_cast<unsigned int>( child.GetProperty( Toolkit::TableView::ChildProperty::COLUMN_SPAN ).Get<float>() );
1001     }
1002
1003     if( child.GetPropertyType( Toolkit::TableView::ChildProperty::CELL_INDEX ) != Property::NONE )
1004     {
1005       Vector2 indices = child.GetProperty( Toolkit::TableView::ChildProperty::CELL_INDEX ).Get<Vector2 >();
1006       cellPosition.rowIndex = static_cast<unsigned int>( indices.x );
1007       cellPosition.columnIndex = static_cast<unsigned int>( indices.y );
1008
1009       AddChild( child, cellPosition );
1010       SetCellAlignment(cellPosition, horizontalAlignment, verticalAlignment);
1011     }
1012     else
1013     {
1014       bool availableCellFound = false;
1015
1016       // Find the first available cell to store the actor in
1017       const unsigned int rowCount = mCellData.GetRows();
1018       const unsigned int columnCount = mCellData.GetColumns();
1019       for( unsigned int row = 0; row < rowCount && !availableCellFound; ++row )
1020       {
1021         for( unsigned int column = 0; column < columnCount && !availableCellFound; ++column )
1022         {
1023           if( !(mCellData[ row ][ column ].actor) )
1024           {
1025             // Put the actor in the cell
1026             CellData data;
1027             data.actor = child;
1028             data.position.columnIndex = column;
1029             data.position.rowIndex = row;
1030             data.horizontalAlignment = horizontalAlignment;
1031             data.verticalAlignment = verticalAlignment;
1032             mCellData[ row ][ column ] = data;
1033
1034             availableCellFound = true;
1035             break;
1036           }
1037         }
1038       }
1039
1040       if( ! availableCellFound )
1041       {
1042         // No empty cells, so increase size of the table
1043         unsigned int newColumnCount = ( columnCount > 0 ) ? columnCount : 1;
1044         ResizeContainers( rowCount + 1, newColumnCount );
1045
1046         // Put the actor in the first cell of the new row
1047         CellData data;
1048         data.actor = child;
1049         data.position.rowIndex = rowCount;
1050         data.position.columnIndex = 0;
1051         data.horizontalAlignment = horizontalAlignment;
1052         data.verticalAlignment = verticalAlignment;
1053         mCellData[ rowCount ][ 0 ] = data;
1054       }
1055
1056       RelayoutRequest();
1057     }
1058   }
1059
1060   Control::OnChildAdd( child );
1061 }
1062
1063 void TableView::OnChildRemove( Actor& child )
1064 {
1065   // dont process if we're in the middle of bigger operation like delete row, column or resize
1066   if( !mLayoutingChild )
1067   {
1068     // relayout the table only if instances were found
1069     if( RemoveAllInstances( child ) )
1070     {
1071       RelayoutRequest();
1072     }
1073   }
1074
1075   Control::OnChildRemove( child );
1076 }
1077
1078 TableView::TableView( unsigned int initialRows, unsigned int initialColumns )
1079 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
1080   mCellData( initialRows, initialColumns ),
1081   mLayoutingChild( false ),
1082   mRowDirty( true ),     // Force recalculation first time
1083   mColumnDirty( true )
1084 {
1085   mCurrentColumn = 0;
1086   mCurrentRow = 0;
1087   SetKeyboardNavigationSupport( true );
1088   ResizeContainers( initialRows, initialColumns );
1089 }
1090
1091 void TableView::OnInitialize()
1092 {
1093   // Make self as keyboard focusable and focus group
1094   Actor self = Self();
1095   self.SetKeyboardFocusable(true);
1096   SetAsKeyboardFocusGroup(true);
1097 }
1098
1099 void TableView::ResizeContainers( unsigned int rows, unsigned int columns )
1100 {
1101   std::vector<CellData> ignored;
1102   ResizeContainers( rows, columns, ignored );
1103 }
1104
1105 void TableView::ResizeContainers( unsigned int rows, unsigned int columns, std::vector<CellData>& removed )
1106 {
1107   // Resize cell data
1108   mCellData.Resize( rows, columns, removed );
1109
1110   // We don't care if these go smaller, data will be regenerated or is not needed anymore
1111   mRowData.Resize( rows );
1112   mColumnData.Resize( columns );
1113 }
1114
1115 void TableView::RemoveAndGetLostActors( const std::vector<CellData>& lost, std::vector<Actor>& removed,
1116                                         unsigned int rowsRemoved, unsigned int columnsRemoved )
1117 {
1118   // iterate through all lost cells
1119   std::vector< CellData >::const_iterator iter = lost.begin();
1120   for( ; iter != lost.end(); ++iter )
1121   {
1122     // if it is a valid actor
1123     if( (*iter).actor )
1124     {
1125       // is this actor still somewhere else in the table
1126       Toolkit::TableView::CellPosition position;
1127       if( FindChildPosition( (*iter).actor, position ) )
1128       {
1129         // it must be spanning multiple cells, position contains the top left most one
1130         // check if position is left of the removed location
1131         if( position.columnIndex < (*iter).position.columnIndex )
1132         {
1133           // if column span is greater than 1
1134           if( mCellData[ position.rowIndex ][ position.columnIndex ].position.columnSpan > 1 )
1135           {
1136             // decrease column span
1137             mCellData[ position.rowIndex ][ position.columnIndex ].position.columnSpan -= columnsRemoved;
1138           }
1139         }
1140         // check if position is left of the removed location
1141         if( position.rowIndex < (*iter).position.rowIndex )
1142         {
1143           // if row span is greater than 1
1144           if( mCellData[ position.rowIndex ][ position.columnIndex ].position.rowSpan > 1 )
1145           {
1146             // decrease row span
1147             mCellData[ position.rowIndex ][ position.columnIndex ].position.rowSpan -= rowsRemoved;
1148           }
1149         }
1150       }
1151       else
1152       {
1153         // this actor is gone for good
1154         // add actor to removed container
1155         removed.push_back( (*iter).actor );
1156         // we dont want the child actor anymore
1157         Self().Remove( (*iter).actor );
1158       }
1159     }
1160   }
1161 }
1162
1163 bool TableView::RemoveAllInstances( const Actor& child )
1164 {
1165   bool found = false;
1166   // walk through the layout data
1167   const unsigned int rowCount = mCellData.GetRows();
1168   const unsigned int columnCount = mCellData.GetColumns();
1169   for( unsigned int row = 0; row < rowCount; ++row )
1170   {
1171     for( unsigned int column = 0; column < columnCount; ++column )
1172     {
1173       if( mCellData[ row ][ column ].actor == child )
1174       {
1175         // clear the cell, NOTE that the cell might be spanning multiple cells
1176         mCellData[ row ][ column ] = CellData();
1177         found = true;
1178       }
1179     }
1180   }
1181   return found;
1182 }
1183
1184 void TableView::SetHeightOrWidthProperty(TableView& tableViewImpl,
1185                                          void(TableView::*funcFixed)(unsigned int, float),
1186                                          void(TableView::*funcRelative)(unsigned int, float),
1187                                          void(TableView::*funcFit)(unsigned int),
1188                                          const Property::Value& value )
1189 {
1190   Property::Map* map = value.GetMap();
1191   if( map )
1192   {
1193     unsigned int index(0);
1194     for ( unsigned int i = 0, count = map->Count(); i < count; ++i )
1195     {
1196       Property::Value& item = map->GetValue(i);
1197       Property::Map* childMap = item.GetMap();
1198
1199       std::istringstream( map->GetKey(i) ) >> index;
1200       if( childMap )
1201       {
1202         Property::Value* policy = childMap->Find( "policy" );
1203         Property::Value* childMapValue = childMap->Find( "value" );
1204         if( policy && childMapValue )
1205         {
1206           std::string policyValue;
1207           policy->Get( policyValue );
1208           Toolkit::TableView::LayoutPolicy policy;
1209           if( Scripting::GetEnumeration< Toolkit::TableView::LayoutPolicy >( policyValue.c_str(),
1210                                                                              LAYOUT_POLICY_STRING_TABLE,
1211                                                                              LAYOUT_POLICY_STRING_TABLE_COUNT,
1212                                                                              policy ) )
1213           {
1214             if( policy == Toolkit::TableView::FIXED  )
1215             {
1216               (tableViewImpl.*funcFixed)( index, childMapValue->Get<float>() );
1217             }
1218             else if( policy == Toolkit::TableView::RELATIVE )
1219             {
1220               (tableViewImpl.*funcRelative)( index, childMapValue->Get<float>() );
1221             }
1222             else if( policy == Toolkit::TableView::FIT )
1223             {
1224               (tableViewImpl.*funcFit)( index );
1225             }
1226             // do nothing for FILL policy
1227           }
1228         }
1229       }
1230     }
1231   }
1232 }
1233
1234 Property::Value TableView::GetRowHeightsPropertyValue()
1235 {
1236   Property::Map map;
1237   GetMapPropertyValue( mRowData, map);
1238   return Property::Value(map);
1239 }
1240
1241 Property::Value TableView::GetColumnWidthsPropertyValue()
1242 {
1243   Property::Map map;
1244   GetMapPropertyValue( mColumnData, map);
1245   return Property::Value(map);
1246 }
1247
1248 void TableView::GetMapPropertyValue( const RowColumnArray& data, Property::Map& map )
1249 {
1250   const char* fixedPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FIXED,
1251                                                                                                LAYOUT_POLICY_STRING_TABLE,
1252                                                                                                LAYOUT_POLICY_STRING_TABLE_COUNT );
1253   const char* relativePolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::RELATIVE,
1254                                                                                                   LAYOUT_POLICY_STRING_TABLE,
1255                                                                                                   LAYOUT_POLICY_STRING_TABLE_COUNT );
1256   const char* fillPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FILL,
1257                                                                                               LAYOUT_POLICY_STRING_TABLE,
1258                                                                                               LAYOUT_POLICY_STRING_TABLE_COUNT );
1259   const char* fitPolicy = Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::FIT,
1260                                                                                              LAYOUT_POLICY_STRING_TABLE,
1261                                                                                              LAYOUT_POLICY_STRING_TABLE_COUNT );
1262
1263   const RowColumnArray::SizeType count = data.Size();
1264   for( RowColumnArray::SizeType i = 0; i < count; i++ )
1265   {
1266     const RowColumnData& dataInstance = data[ i ];
1267
1268     Property::Map item;
1269     switch( dataInstance.sizePolicy )
1270     {
1271       case Toolkit::TableView::FIXED:
1272       {
1273         item[ "policy" ] = fixedPolicy;
1274         item[ "value" ] = dataInstance.size;
1275         break;
1276       }
1277       case Toolkit::TableView::RELATIVE:
1278       {
1279         item[ "policy" ] = relativePolicy;
1280         item[ "value" ] = dataInstance.fillRatio;
1281         break;
1282       }
1283       case Toolkit::TableView::FIT:
1284       {
1285         item[ "policy" ] = fitPolicy;
1286         item[ "value" ] = 0.f;
1287         break;
1288       }
1289       case Toolkit::TableView::FILL:
1290       default:
1291       {
1292         item[ "policy" ] = fillPolicy;
1293         item[ "value" ] = 0.f;
1294         break;
1295       }
1296     }
1297     std::ostringstream ss;
1298     ss << i;
1299     map[ ss.str() ] = item;
1300   }
1301 }
1302
1303 TableView::~TableView()
1304 {
1305   // nothing to do
1306 }
1307
1308 Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
1309 {
1310   Actor nextFocusableActor;
1311
1312   if ( !currentFocusedActor )
1313   {
1314     // Nothing is currently focused, so the child in the first cell should be focused.
1315     nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(0, 0));
1316   }
1317   else
1318   {
1319     Toolkit::TableView::CellPosition position;
1320     if( FindChildPosition( currentFocusedActor, position ) )
1321     {
1322       // The current focused actor is a child of TableView
1323       bool focusLost = false;
1324       int currentRow = position.rowIndex;
1325       int currentColumn = position.columnIndex;
1326       int numberOfColumns = GetColumns();
1327       int numberOfRows = GetRows();
1328
1329       bool lastCell = false;
1330       Actor nextValidActor;
1331
1332       switch ( direction )
1333       {
1334         case Toolkit::Control::KeyboardFocus::LEFT:
1335         {
1336           do
1337           {
1338             if(--currentColumn < 0)
1339             {
1340               currentColumn = numberOfColumns - 1;
1341               if(--currentRow < 0)
1342               {
1343                 lastCell = true;
1344                 currentRow = loopEnabled ? numberOfRows - 1 : 0;
1345                 focusLost = (currentRow == 0);
1346               }
1347             }
1348             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1349           } while ( !nextValidActor && !lastCell );
1350           break;
1351         }
1352         case Toolkit::Control::KeyboardFocus::RIGHT:
1353         {
1354           do
1355           {
1356             if(++currentColumn > numberOfColumns - 1)
1357             {
1358               currentColumn = 0;
1359               if(++currentRow > numberOfRows - 1)
1360               {
1361                 lastCell = true;
1362                 currentRow = loopEnabled ? 0 : numberOfRows - 1;
1363                 focusLost = (currentRow == numberOfRows - 1);
1364               }
1365             }
1366             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1367           } while ( !nextValidActor && !lastCell );
1368           break;
1369         }
1370         case Toolkit::Control::KeyboardFocus::UP:
1371         {
1372           do
1373           {
1374             if(--currentRow < 0)
1375             {
1376               lastCell = true;
1377               currentRow = loopEnabled ? numberOfRows - 1 : 0;
1378               focusLost = (currentRow == 0);
1379             }
1380             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1381           } while ( !nextValidActor && !lastCell );
1382           break;
1383         }
1384         case Toolkit::Control::KeyboardFocus::DOWN:
1385
1386         {
1387           do
1388           {
1389             if(++currentRow > numberOfRows - 1)
1390             {
1391               lastCell = true;
1392               currentRow = loopEnabled ? 0 : numberOfRows - 1;
1393               focusLost = (currentRow == numberOfRows - 1);
1394             }
1395             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1396           } while ( !nextValidActor && !lastCell );
1397           break;
1398         }
1399         default:
1400         {
1401           break;
1402         }
1403       }
1404
1405       // Move the focus if we haven't lost it.
1406       if(!focusLost)
1407       {
1408         // Save the new focus cell positions of TableView.
1409         mCurrentColumn = currentColumn;
1410         mCurrentRow = currentRow;
1411
1412         nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1413       }
1414     }
1415     else
1416     {
1417       // The current focused actor is not within TableView.
1418       // This means that the TableView has gained the Focus again.
1419
1420       unsigned int numberOfColumns = GetColumns();
1421       unsigned int numberOfRows = GetRows();
1422
1423       if( (mCurrentRow != 0 && mCurrentColumn != 0) && // Last saved cell was not the first cell
1424           (mCurrentRow != numberOfRows - 1 && mCurrentColumn != numberOfColumns - 1) ) // Last saved cell was not the last cell
1425       {
1426         // This condition handles the cases when parent TableView gained the focus again after the child layout
1427         // container (i.e. TableView) has no more items (i.e. actors) to be focused on in a given direction.
1428
1429         // Move the focus to next cell towards the given direction in a TableView if the last saved cell was not the first or last cell.
1430         nextFocusableActor = GetNextKeyboardFocusableActor(GetChildAt(Toolkit::TableView::CellPosition(mCurrentRow, mCurrentColumn)), direction, loopEnabled);
1431       }
1432       else
1433       {
1434         // Otherwise, move the focus to either the first or the last cell according to the given direction.
1435         if(direction == Toolkit::Control::KeyboardFocus::LEFT || direction == Toolkit::Control::KeyboardFocus::UP)
1436         {
1437           nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(numberOfRows - 1, numberOfColumns - 1));
1438         }
1439         else
1440         {
1441           nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(0, 0));
1442         }
1443       }
1444     }
1445   }
1446
1447   return nextFocusableActor;
1448 }
1449
1450 Vector3 TableView::GetNaturalSize()
1451 {
1452   // Natural size is the size of all fixed cell widths or heights. This ignores cells with relative heights.
1453   return Vector3( mFixedTotals.width, mFixedTotals.height, 1.0f );
1454 }
1455
1456 float TableView::CalculateChildSize( const Actor& child, Dimension::Type dimension )
1457 {
1458   Toolkit::TableView::CellPosition position;
1459   if( FindChildPosition( child, position) )
1460   {
1461     switch( dimension )
1462     {
1463       case Dimension::WIDTH:
1464       {
1465         float cellSize = 0.0f;
1466         cellSize = mColumnData[position.columnIndex+position.columnSpan-1].position
1467                  - (position.columnIndex > 0 ? mColumnData[position.columnIndex-1].position : 0.f)
1468                  - mPadding.width * 2.0f;
1469
1470         if( cellSize < 0.0f )
1471         {
1472           cellSize = 0.0f;
1473         }
1474
1475         return cellSize;
1476       }
1477
1478       case Dimension::HEIGHT:
1479       {
1480         float cellSize = 0.0f;
1481
1482         cellSize = mRowData[position.rowIndex+position.rowSpan-1].position
1483                  - (position.rowIndex > 0 ? mRowData[position.rowIndex-1].position : 0.f)
1484                  - mPadding.height * 2.0f;
1485
1486         if( cellSize < 0.0f )
1487         {
1488           cellSize = 0.0f;
1489         }
1490
1491         return cellSize;
1492       }
1493       default:
1494       {
1495         return 0.0f;
1496       }
1497     }
1498   }
1499
1500   return 0.0f;    // Child not found
1501 }
1502
1503 bool TableView::RelayoutDependentOnChildren( Dimension::Type dimension )
1504 {
1505   if ( Control::RelayoutDependentOnChildren( dimension ) )
1506   {
1507     return true;
1508   }
1509
1510   return FindFit( mRowData ) || FindFit( mColumnData );
1511 }
1512
1513 void TableView::SetCellAlignment( Toolkit::TableView::CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical )
1514 {
1515   // Check if we need to expand our data array
1516   if( position.rowIndex >= mCellData.GetRows() )
1517   {
1518     // Only adding new rows
1519     ResizeContainers( position.rowIndex + 1, mCellData.GetColumns() );
1520   }
1521
1522   if( position.columnIndex >= mCellData.GetColumns() )
1523   {
1524     // Only adding new columns
1525     ResizeContainers( mCellData.GetRows(), position.columnIndex + 1 );
1526   }
1527
1528   // Set the alignment of the cell
1529   CellData& data = mCellData[ position.rowIndex ][ position.columnIndex ];
1530   data.horizontalAlignment = horizontal;
1531   data.verticalAlignment = vertical;
1532 }
1533
1534 void TableView::CalculateFillSizes( RowColumnArray& data )
1535 {
1536   // First pass: Count number of fill entries and calculate used relative space
1537   Dali::Vector< RowColumnData* > fillData;
1538   float relativeTotal = 0.0f;
1539
1540   const unsigned int dataCount = data.Size();
1541
1542   for( unsigned int i = 0; i < dataCount; ++i )
1543   {
1544     RowColumnData& dataInstance = data[ i ];
1545
1546     if( dataInstance.sizePolicy == Toolkit::TableView::RELATIVE )
1547     {
1548       relativeTotal += dataInstance.fillRatio;
1549     }
1550     else if(dataInstance.sizePolicy == Toolkit::TableView::FILL)
1551     {
1552       fillData.PushBack( &dataInstance );
1553     }
1554   }
1555
1556   // Second pass: Distribute remaining relative space
1557   const unsigned int fillCount = fillData.Size();
1558   if( fillCount > 0 )
1559   {
1560     if( relativeTotal > 1.0f )
1561     {
1562       relativeTotal = 1.0f;
1563     }
1564
1565     const float evenFillRatio = (1.0f - relativeTotal ) / fillCount;
1566
1567     for( unsigned int i = 0; i < fillCount; ++i )
1568     {
1569       fillData[ i ]->fillRatio = evenFillRatio;
1570     }
1571   }
1572 }
1573
1574 float TableView::CalculateTotalFixedSize( const RowColumnArray& data )
1575 {
1576   float totalSize = 0.0f;
1577
1578   const unsigned int dataCount = data.Size();
1579
1580   for( unsigned int i = 0; i < dataCount; ++i )
1581   {
1582     const RowColumnData& dataInstance = data[ i ];
1583
1584     switch( dataInstance.sizePolicy )
1585     {
1586       // we have absolute size to FIXED and FIT column/row and relative size for RELATIVE and FILL column/row
1587       case Toolkit::TableView::FIXED:
1588       case Toolkit::TableView::FIT:
1589       {
1590         totalSize += dataInstance.size;
1591         break;
1592       }
1593
1594       default:
1595       {
1596         break;
1597       }
1598     }
1599   }
1600
1601   return totalSize;
1602 }
1603
1604 Vector2 TableView::GetCellPadding( Dimension::Type dimension )
1605 {
1606   switch( dimension )
1607   {
1608     case Dimension::WIDTH:
1609     {
1610       return Vector2( mPadding.x, mPadding.x );
1611     }
1612     case Dimension::HEIGHT:
1613     {
1614       return Vector2( mPadding.y, mPadding.y );
1615     }
1616     default:
1617     {
1618       break;
1619     }
1620   }
1621
1622   return Vector2();
1623 }
1624
1625 void TableView::CalculateFitSizes( RowColumnArray& data, Dimension::Type dimension )
1626 {
1627   Vector2 cellPadding = GetCellPadding( dimension );
1628
1629   const unsigned int dataCount = data.Size();
1630
1631   for( unsigned int i = 0; i < dataCount; ++i )
1632   {
1633     RowColumnData& dataInstance = data[ i ];
1634
1635     if( dataInstance.sizePolicy == Toolkit::TableView::FIT )
1636     {
1637       // Find the size of the biggest actor in the row or column
1638       float maxActorHeight = 0.0f;
1639
1640       unsigned int fitCount = ( dimension == Dimension::WIDTH ) ? mCellData.GetRows() : mCellData.GetColumns();
1641
1642       for( unsigned int j = 0; j < fitCount; ++j )
1643       {
1644         unsigned int row = ( dimension == Dimension::WIDTH ) ? j : i;
1645         unsigned int column = ( dimension == Dimension::WIDTH ) ? i : j;
1646         DALI_ASSERT_DEBUG( row < mCellData.GetRows() );
1647         DALI_ASSERT_DEBUG( column < mCellData.GetColumns() );
1648
1649         const CellData& cellData = mCellData[ row ][ column ];
1650         const Actor& actor = cellData.actor;
1651         if( actor )
1652         {
1653           if( FitToChild( actor, dimension ) && ( dimension == Dimension::WIDTH ) ? ( cellData.position.columnSpan == 1 ) : ( cellData.position.rowSpan == 1 )  )
1654           {
1655             maxActorHeight = std::max( maxActorHeight, actor.GetRelayoutSize( dimension ) + cellPadding.x + cellPadding.y );
1656           }
1657         }
1658       }
1659
1660       dataInstance.size = maxActorHeight;
1661     }
1662   }
1663 }
1664
1665 bool TableView::FindFit( const RowColumnArray& data )
1666 {
1667   for( unsigned int i = 0, count = data.Size(); i < count; ++i )
1668   {
1669     if( data[ i ].sizePolicy == Toolkit::TableView::FIT )
1670     {
1671       return true;
1672     }
1673   }
1674
1675   return false;
1676 }
1677
1678 } // namespace Internal
1679
1680 } // namespace Toolkit
1681
1682 } // namespace Dali