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

   1 /*
   2  * Copyright (c) 2021 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 <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/devel-api/scripting/scripting.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/public-api/object/ref-object.h>
  26 #include <dali/public-api/object/type-registry-helper.h>
  27 #include <dali/public-api/object/type-registry.h>
  28 #include <dali/public-api/size-negotiation/relayout-container.h>
  29 #include <sstream>
  30
  31 // INTERNAL INCLUDES
  32 #include <dali-toolkit/devel-api/controls/control-devel.h>
  33
  34 using namespace Dali;
  35
  36 namespace
  37 {
  38 /**
  39  * @brief Should the tableview fit around the given actor
  40  *
  41  * @param[in] actor The child actor to test against
  42  * @param[dimension] The dimension to test against
  43  */
  44 bool FitToChild(Actor actor, Dimension::Type dimension)
  45 {
  46   return actor.GetResizePolicy(dimension) != ResizePolicy::FILL_TO_PARENT && actor.GetRelayoutSize(dimension) > 0.0f;
  47 }
  48
  49 #if defined(DEBUG_ENABLED)
  50 // debugging support, very useful when new features are added or bugs are hunted down
  51 // currently not called from code so compiler will optimize these away, kept here for future debugging
  52
  53 #define TABLEVIEW_TAG "DALI Toolkit::TableView "
  54 #define TV_LOG(fmt, args, ...) Debug::LogMessage(Debug::DebugInfo, TABLEVIEW_TAG fmt, ##args)
  55 //#define TABLEVIEW_DEBUG 1
  56
  57 #if defined(TABLEVIEW_DEBUG)
  58 void PrintArray(Array2d<Dali::Toolkit::Internal::TableView::CellData>& array)
  59 {
  60   TV_LOG("Array2d<CellData> size [%d,%d] \n", array.GetRows(), array.GetColumns());
  61   // print values
  62   for(unsigned int i = 0; i < array.GetRows(); ++i)
  63   {
  64     for(unsigned int j = 0; j < array.GetColumns(); ++j)
  65     {
  66       Dali::Toolkit::Internal::TableView::CellData data  = array[i][j];
  67       char                                         actor = ' ';
  68       std::string                                  actorName;
  69       if(data.actor)
  70       {
  71         actor     = 'A';
  72         actorName = data.actor.GetProperty<std::string>(Dali::Actor::Property::NAME);
  73       }
  74       TV_LOG("Array[%d,%d]=%c %s %d,%d,%d,%d  ", i, j, actor, actorName.c_str(), data.position.rowIndex, data.position.columnIndex, data.position.rowSpan, data.position.columnSpan);
  75     }
  76     TV_LOG("\n");
  77   }
  78 }
  79
  80 // debugging support, very useful when new features are added or bugs are hunted down
  81 // currently not called from code so compiler will optimize these away, kept here for future debugging
  82 void PrintArray(Array2d<Size>& array)
  83 {
  84   TV_LOG("Array2d<Size> size [%d,%d] \n", array.GetRows(), array.GetColumns());
  85   // print values
  86   for(unsigned int i = 0; i < array.GetRows(); ++i)
  87   {
  88     for(unsigned int j = 0; j < array.GetColumns(); ++j)
  89     {
  90       TV_LOG("Array[%d,%d]=%.2f,%.2f ", i, j, array[i][j].width, array[i][j].height);
  91     }
  92     TV_LOG("\n");
  93   }
  94 }
  95 // debugging support, very useful when new features are added or bugs are hunted down
  96 // currently not called from code so compiler will optimize these away, kept here for future debugging
  97 void PrintVector(std::vector<float>& array)
  98 {
  99   TV_LOG("vector, size [%d]\n", array.size());
 100   // print values
 101   for(unsigned int i = 0; i < array.size(); ++i)
 102   {
 103     TV_LOG("vector[%d]=%.2f ", i, array[i]);
 104   }
 105   TV_LOG("\n");
 106 }
 107 #endif // defined(TABLEVIEW_DEBUG)
 108 #endif // defined(DEBUG_ENABLED)
 109
 110 } // namespace
 111
 112 namespace Dali
 113 {
 114 namespace Toolkit
 115 {
 116 namespace Internal
 117 {
 118 namespace
 119 {
 120 // Type registration
 121 BaseHandle Create()
 122 {
 123   return Toolkit::TableView::New(0, 0);
 124 }
 125
 126 // clang-format off
 127 // Setup properties, signals and actions using the type-registry.
 128 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::TableView, Toolkit::Control, Create);
 129
 130 DALI_PROPERTY_REGISTRATION(Toolkit, TableView, "rows",          INTEGER, ROWS          )
 131 DALI_PROPERTY_REGISTRATION(Toolkit, TableView, "columns",       INTEGER, COLUMNS       )
 132 DALI_PROPERTY_REGISTRATION(Toolkit, TableView, "cellPadding",   VECTOR2, CELL_PADDING  )
 133 DALI_PROPERTY_REGISTRATION(Toolkit, TableView, "layoutRows",    MAP,     LAYOUT_ROWS   )
 134 DALI_PROPERTY_REGISTRATION(Toolkit, TableView, "layoutColumns", MAP,     LAYOUT_COLUMNS)
 135
 136 DALI_CHILD_PROPERTY_REGISTRATION(Toolkit, TableView, "cellIndex",               VECTOR2, CELL_INDEX               )
 137 DALI_CHILD_PROPERTY_REGISTRATION(Toolkit, TableView, "rowSpan",                 INTEGER, ROW_SPAN                 )
 138 DALI_CHILD_PROPERTY_REGISTRATION(Toolkit, TableView, "columnSpan",              INTEGER, 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 // clang-format on
 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(auto&& element : mColumnData)
 753     {
 754       if(element.sizePolicy == Toolkit::TableView::FILL || element.sizePolicy == Toolkit::TableView::RELATIVE)
 755       {
 756         element.size = element.fillRatio * remainingSize;
 757       }
 758
 759       cumulatedWidth += element.size;
 760       element.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   float totalWidth = 0.0;
 806
 807   Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
 808
 809   if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
 810   {
 811     for(auto&& element : mColumnData)
 812     {
 813       totalWidth += element.size;
 814     }
 815   }
 816
 817   for(unsigned int row = 0, rowCount = mCellData.GetRows(); row < rowCount; ++row)
 818   {
 819     for(unsigned int column = 0, columnCount = mCellData.GetColumns(); column < columnCount; ++column)
 820     {
 821       CellData&                              cellData = mCellData[row][column];
 822       Actor&                                 actor    = cellData.actor;
 823       const Toolkit::TableView::CellPosition position = cellData.position;
 824
 825       // If there is an actor and this is the main cell of the actor.
 826       // An actor can be in multiple cells if its row or column span is more than 1.
 827       // We however must lay out each actor only once.
 828       if(actor && position.rowIndex == row && position.columnIndex == column)
 829       {
 830         // Anchor actor to top left of the cell
 831         if(actor.GetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT).Get<bool>())
 832         {
 833           actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 834         }
 835         actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 836
 837         Padding padding = actor.GetProperty<Vector4>(Actor::Property::PADDING);
 838
 839         float left = (column > 0) ? mColumnData[column - 1].position : 0.f;
 840         float right;
 841
 842         if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
 843         {
 844           right = totalWidth - left;
 845           left  = right - mColumnData[column].size;
 846         }
 847         else
 848         {
 849           right = left + mColumnData[column].size;
 850         }
 851
 852         float top    = row > 0 ? mRowData[row - 1].position : 0.f;
 853         float bottom = mRowData[row + position.rowSpan - 1].position;
 854
 855         if(cellData.horizontalAlignment == HorizontalAlignment::LEFT)
 856         {
 857           actor.SetProperty(Actor::Property::POSITION_X, left + mPadding.width + padding.left);
 858         }
 859         else if(cellData.horizontalAlignment == HorizontalAlignment::RIGHT)
 860         {
 861           actor.SetProperty(Actor::Property::POSITION_X, right - mPadding.width - padding.right - actor.GetRelayoutSize(Dimension::WIDTH));
 862         }
 863         else //if( cellData.horizontalAlignment ==  HorizontalAlignment::CENTER )
 864         {
 865           actor.SetProperty(Actor::Property::POSITION_X, (left + right + padding.left - padding.right - actor.GetRelayoutSize(Dimension::WIDTH)) * 0.5f);
 866         }
 867
 868         if(cellData.verticalAlignment == VerticalAlignment::TOP)
 869         {
 870           actor.SetProperty(Actor::Property::POSITION_Y, top + mPadding.height + padding.top);
 871         }
 872         else if(cellData.verticalAlignment == VerticalAlignment::BOTTOM)
 873         {
 874           actor.SetProperty(Actor::Property::POSITION_Y, bottom - mPadding.height - padding.bottom - actor.GetRelayoutSize(Dimension::HEIGHT));
 875         }
 876         else //if( cellData.verticalAlignment = VerticalAlignment::CENTER )
 877         {
 878           actor.SetProperty(Actor::Property::POSITION_Y, (top + bottom + padding.top - padding.bottom - actor.GetRelayoutSize(Dimension::HEIGHT)) * 0.5f);
 879         }
 880       }
 881     }
 882   }
 883 }
 884
 885 unsigned int TableView::GetRows()
 886 {
 887   return mCellData.GetRows();
 888 }
 889
 890 unsigned int TableView::GetColumns()
 891 {
 892   return mCellData.GetColumns();
 893 }
 894
 895 void TableView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 896 {
 897   Toolkit::TableView tableView = Toolkit::TableView::DownCast(Dali::BaseHandle(object));
 898
 899   if(tableView)
 900   {
 901     TableView& tableViewImpl(GetImpl(tableView));
 902     switch(index)
 903     {
 904       case Toolkit::TableView::Property::ROWS:
 905       {
 906         int rows = 0;
 907         if(value.Get(rows) && rows >= 0)
 908         {
 909           if(static_cast<unsigned int>(rows) != tableViewImpl.GetRows())
 910           {
 911             tableViewImpl.Resize(rows, tableViewImpl.GetColumns());
 912           }
 913         }
 914         break;
 915       }
 916       case Toolkit::TableView::Property::COLUMNS:
 917       {
 918         int columns = 0;
 919         if(value.Get(columns) && columns >= 0)
 920         {
 921           if(static_cast<unsigned int>(columns) != tableViewImpl.GetColumns())
 922           {
 923             tableViewImpl.Resize(tableViewImpl.GetRows(), value.Get<int>());
 924           }
 925         }
 926         break;
 927       }
 928       case Toolkit::TableView::Property::CELL_PADDING:
 929       {
 930         tableViewImpl.SetCellPadding(value.Get<Vector2>());
 931         break;
 932       }
 933       case Toolkit::TableView::Property::LAYOUT_ROWS:
 934       {
 935         SetHeightOrWidthProperty(tableViewImpl, &TableView::SetFixedHeight, &TableView::SetRelativeHeight, &TableView::SetFitHeight, value);
 936         break;
 937       }
 938       case Toolkit::TableView::Property::LAYOUT_COLUMNS:
 939       {
 940         SetHeightOrWidthProperty(tableViewImpl, &TableView::SetFixedWidth, &TableView::SetRelativeWidth, &TableView::SetFitWidth, value);
 941         break;
 942       }
 943     }
 944   }
 945 }
 946
 947 Property::Value TableView::GetProperty(BaseObject* object, Property::Index index)
 948 {
 949   Property::Value value;
 950
 951   Toolkit::TableView tableView = Toolkit::TableView::DownCast(Dali::BaseHandle(object));
 952
 953   if(tableView)
 954   {
 955     TableView& tableViewImpl(GetImpl(tableView));
 956     switch(index)
 957     {
 958       case Toolkit::TableView::Property::ROWS:
 959       {
 960         value = static_cast<int>(tableViewImpl.GetRows());
 961         break;
 962       }
 963       case Toolkit::TableView::Property::COLUMNS:
 964       {
 965         value = static_cast<int>(tableViewImpl.GetColumns());
 966         break;
 967       }
 968       case Toolkit::TableView::Property::CELL_PADDING:
 969       {
 970         value = tableViewImpl.GetCellPadding();
 971         break;
 972       }
 973       case Toolkit::TableView::Property::LAYOUT_ROWS:
 974       {
 975         value = tableViewImpl.GetRowHeightsPropertyValue();
 976         break;
 977       }
 978       case Toolkit::TableView::Property::LAYOUT_COLUMNS:
 979       {
 980         value = tableViewImpl.GetColumnWidthsPropertyValue();
 981         break;
 982       }
 983     }
 984   }
 985
 986   return value;
 987 }
 988
 989 void TableView::OnChildAdd(Actor& child)
 990 {
 991   if(!mLayoutingChild)
 992   {
 993     // Ensure we're not in the middle of laying out children
 994
 995     // Check child properties on actor to decide its position inside the table
 996     HorizontalAlignment::Type horizontalAlignment = HorizontalAlignment::LEFT;
 997     VerticalAlignment::Type   verticalAlignment   = VerticalAlignment::TOP;
 998
 999     if(child.GetPropertyType(Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT) != Property::NONE)
1000     {
1001       std::string value = child.GetProperty(Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT).Get<std::string>();
1002       Scripting::GetEnumeration<HorizontalAlignment::Type>(value.c_str(),
1003                                                            HORIZONTAL_ALIGNMENT_STRING_TABLE,
1004                                                            HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT,
1005                                                            horizontalAlignment);
1006     }
1007
1008     if(child.GetPropertyType(Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT) != Property::NONE)
1009     {
1010       std::string value = child.GetProperty(Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT).Get<std::string>();
1011       Scripting::GetEnumeration<VerticalAlignment::Type>(value.c_str(),
1012                                                          VERTICAL_ALIGNMENT_STRING_TABLE,
1013                                                          VERTICAL_ALIGNMENT_STRING_TABLE_COUNT,
1014                                                          verticalAlignment);
1015     }
1016
1017     Toolkit::TableView::CellPosition cellPosition;
1018     if(child.GetPropertyType(Toolkit::TableView::ChildProperty::ROW_SPAN) != Property::NONE)
1019     {
1020       cellPosition.rowSpan = child.GetProperty(Toolkit::TableView::ChildProperty::ROW_SPAN).Get<int>();
1021     }
1022
1023     if(child.GetPropertyType(Toolkit::TableView::ChildProperty::COLUMN_SPAN) != Property::NONE)
1024     {
1025       cellPosition.columnSpan = child.GetProperty(Toolkit::TableView::ChildProperty::COLUMN_SPAN).Get<int>();
1026     }
1027
1028     if(child.GetPropertyType(Toolkit::TableView::ChildProperty::CELL_INDEX) != Property::NONE)
1029     {
1030       Vector2 indices          = child.GetProperty(Toolkit::TableView::ChildProperty::CELL_INDEX).Get<Vector2>();
1031       cellPosition.rowIndex    = static_cast<unsigned int>(indices.x);
1032       cellPosition.columnIndex = static_cast<unsigned int>(indices.y);
1033
1034       AddChild(child, cellPosition);
1035       SetCellAlignment(cellPosition, horizontalAlignment, verticalAlignment);
1036     }
1037     else
1038     {
1039       bool availableCellFound = false;
1040
1041       // Find the first available cell to store the actor in
1042       const unsigned int rowCount    = mCellData.GetRows();
1043       const unsigned int columnCount = mCellData.GetColumns();
1044       for(unsigned int row = 0; row < rowCount && !availableCellFound; ++row)
1045       {
1046         for(unsigned int column = 0; column < columnCount && !availableCellFound; ++column)
1047         {
1048           if(!(mCellData[row][column].actor))
1049           {
1050             // Put the actor in the cell
1051             CellData data;
1052             data.actor                = child;
1053             data.position.columnIndex = column;
1054             data.position.rowIndex    = row;
1055             data.horizontalAlignment  = horizontalAlignment;
1056             data.verticalAlignment    = verticalAlignment;
1057             mCellData[row][column]    = data;
1058
1059             availableCellFound = true;
1060             break;
1061           }
1062         }
1063       }
1064
1065       if(!availableCellFound)
1066       {
1067         // No empty cells, so increase size of the table
1068         unsigned int newColumnCount = (columnCount > 0) ? columnCount : 1;
1069         ResizeContainers(rowCount + 1, newColumnCount);
1070
1071         // Put the actor in the first cell of the new row
1072         CellData data;
1073         data.actor                = child;
1074         data.position.rowIndex    = rowCount;
1075         data.position.columnIndex = 0;
1076         data.horizontalAlignment  = horizontalAlignment;
1077         data.verticalAlignment    = verticalAlignment;
1078         mCellData[rowCount][0]    = data;
1079       }
1080
1081       RelayoutRequest();
1082     }
1083   }
1084
1085   Control::OnChildAdd(child);
1086 }
1087
1088 void TableView::OnChildRemove(Actor& child)
1089 {
1090   // dont process if we're in the middle of bigger operation like delete row, column or resize
1091   if(!mLayoutingChild)
1092   {
1093     // relayout the table only if instances were found
1094     if(RemoveAllInstances(child))
1095     {
1096       RelayoutRequest();
1097     }
1098   }
1099
1100   Control::OnChildRemove(child);
1101 }
1102
1103 TableView::TableView(unsigned int initialRows, unsigned int initialColumns)
1104 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
1105   mCellData(initialRows, initialColumns),
1106   mPreviousFocusedActor(),
1107   mLayoutingChild(false),
1108   mRowDirty(true), // Force recalculation first time
1109   mColumnDirty(true)
1110 {
1111   SetKeyboardNavigationSupport(true);
1112   ResizeContainers(initialRows, initialColumns);
1113 }
1114
1115 void TableView::OnInitialize()
1116 {
1117   // Make self as keyboard focusable and focus group
1118   Actor self = Self();
1119   self.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
1120   SetAsKeyboardFocusGroup(true);
1121
1122   DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) {
1123     return std::unique_ptr<Dali::Accessibility::Accessible>(
1124       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::TABLE));
1125   });
1126 }
1127
1128 void TableView::ResizeContainers(unsigned int rows, unsigned int columns)
1129 {
1130   std::vector<CellData> ignored;
1131   ResizeContainers(rows, columns, ignored);
1132 }
1133
1134 void TableView::ResizeContainers(unsigned int rows, unsigned int columns, std::vector<CellData>& removed)
1135 {
1136   // Resize cell data
1137   mCellData.Resize(rows, columns, removed);
1138
1139   // We don't care if these go smaller, data will be regenerated or is not needed anymore
1140   mRowData.Resize(rows);
1141   mColumnData.Resize(columns);
1142 }
1143
1144 void TableView::RemoveAndGetLostActors(const std::vector<CellData>& lost, std::vector<Actor>& removed, unsigned int rowsRemoved, unsigned int columnsRemoved)
1145 {
1146   // iterate through all lost cells
1147   std::vector<CellData>::const_iterator iter = lost.begin();
1148   for(; iter != lost.end(); ++iter)
1149   {
1150     // if it is a valid actor
1151     if((*iter).actor)
1152     {
1153       // is this actor still somewhere else in the table
1154       Toolkit::TableView::CellPosition position;
1155       if(FindChildPosition((*iter).actor, position))
1156       {
1157         // it must be spanning multiple cells, position contains the top left most one
1158         // check if position is left of the removed location
1159         if(position.columnIndex < (*iter).position.columnIndex)
1160         {
1161           // if column span is greater than 1
1162           if(mCellData[position.rowIndex][position.columnIndex].position.columnSpan > 1)
1163           {
1164             // decrease column span
1165             mCellData[position.rowIndex][position.columnIndex].position.columnSpan -= columnsRemoved;
1166           }
1167         }
1168         // check if position is left of the removed location
1169         if(position.rowIndex < (*iter).position.rowIndex)
1170         {
1171           // if row span is greater than 1
1172           if(mCellData[position.rowIndex][position.columnIndex].position.rowSpan > 1)
1173           {
1174             // decrease row span
1175             mCellData[position.rowIndex][position.columnIndex].position.rowSpan -= rowsRemoved;
1176           }
1177         }
1178       }
1179       else
1180       {
1181         // this actor is gone for good
1182         // add actor to removed container
1183         removed.push_back((*iter).actor);
1184         // we dont want the child actor anymore
1185         Self().Remove((*iter).actor);
1186       }
1187     }
1188   }
1189 }
1190
1191 bool TableView::RemoveAllInstances(const Actor& child)
1192 {
1193   bool found = false;
1194   // walk through the layout data
1195   const unsigned int rowCount    = mCellData.GetRows();
1196   const unsigned int columnCount = mCellData.GetColumns();
1197   for(unsigned int row = 0; row < rowCount; ++row)
1198   {
1199     for(unsigned int column = 0; column < columnCount; ++column)
1200     {
1201       if(mCellData[row][column].actor == child)
1202       {
1203         // clear the cell, NOTE that the cell might be spanning multiple cells
1204         mCellData[row][column] = CellData();
1205         found                  = true;
1206       }
1207     }
1208   }
1209   return found;
1210 }
1211
1212 void TableView::SetHeightOrWidthProperty(TableView& tableViewImpl,
1213                                          void (TableView::*funcFixed)(unsigned int, float),
1214                                          void (TableView::*funcRelative)(unsigned int, float),
1215                                          void (TableView::*funcFit)(unsigned int),
1216                                          const Property::Value& value)
1217 {
1218   const Property::Map* map = value.GetMap();
1219   if(map)
1220   {
1221     unsigned int index(0);
1222     for(unsigned int i = 0, count = map->Count(); i < count; ++i)
1223     {
1224       Property::Value& item     = map->GetValue(i);
1225       Property::Map*   childMap = item.GetMap();
1226
1227       std::istringstream(map->GetKey(i)) >> index;
1228       if(childMap)
1229       {
1230         Property::Value* policy        = childMap->Find("policy");
1231         Property::Value* childMapValue = childMap->Find("value");
1232         if(policy && childMapValue)
1233         {
1234           std::string policyValue;
1235           policy->Get(policyValue);
1236           Toolkit::TableView::LayoutPolicy policy;
1237           if(Scripting::GetEnumeration<Toolkit::TableView::LayoutPolicy>(policyValue.c_str(),
1238                                                                          LAYOUT_POLICY_STRING_TABLE,
1239                                                                          LAYOUT_POLICY_STRING_TABLE_COUNT,
1240                                                                          policy))
1241           {
1242             if(policy == Toolkit::TableView::FIXED)
1243             {
1244               (tableViewImpl.*funcFixed)(index, childMapValue->Get<float>());
1245             }
1246             else if(policy == Toolkit::TableView::RELATIVE)
1247             {
1248               (tableViewImpl.*funcRelative)(index, childMapValue->Get<float>());
1249             }
1250             else if(policy == Toolkit::TableView::FIT)
1251             {
1252               (tableViewImpl.*funcFit)(index);
1253             }
1254             // do nothing for FILL policy
1255           }
1256         }
1257       }
1258     }
1259   }
1260 }
1261
1262 Property::Value TableView::GetRowHeightsPropertyValue()
1263 {
1264   Property::Map map;
1265   GetMapPropertyValue(mRowData, map);
1266   return Property::Value(map);
1267 }
1268
1269 Property::Value TableView::GetColumnWidthsPropertyValue()
1270 {
1271   Property::Map map;
1272   GetMapPropertyValue(mColumnData, map);
1273   return Property::Value(map);
1274 }
1275
1276 void TableView::GetMapPropertyValue(const RowColumnArray& data, Property::Map& map)
1277 {
1278   const char* fixedPolicy    = Scripting::GetEnumerationName<Toolkit::TableView::LayoutPolicy>(Toolkit::TableView::FIXED,
1279                                                                                             LAYOUT_POLICY_STRING_TABLE,
1280                                                                                             LAYOUT_POLICY_STRING_TABLE_COUNT);
1281   const char* relativePolicy = Scripting::GetEnumerationName<Toolkit::TableView::LayoutPolicy>(Toolkit::TableView::RELATIVE,
1282                                                                                                LAYOUT_POLICY_STRING_TABLE,
1283                                                                                                LAYOUT_POLICY_STRING_TABLE_COUNT);
1284   const char* fillPolicy     = Scripting::GetEnumerationName<Toolkit::TableView::LayoutPolicy>(Toolkit::TableView::FILL,
1285                                                                                            LAYOUT_POLICY_STRING_TABLE,
1286                                                                                            LAYOUT_POLICY_STRING_TABLE_COUNT);
1287   const char* fitPolicy      = Scripting::GetEnumerationName<Toolkit::TableView::LayoutPolicy>(Toolkit::TableView::FIT,
1288                                                                                           LAYOUT_POLICY_STRING_TABLE,
1289                                                                                           LAYOUT_POLICY_STRING_TABLE_COUNT);
1290
1291   const RowColumnArray::SizeType count = data.Size();
1292   for(RowColumnArray::SizeType i = 0; i < count; i++)
1293   {
1294     const RowColumnData& dataInstance = data[i];
1295
1296     Property::Map item;
1297     switch(dataInstance.sizePolicy)
1298     {
1299       case Toolkit::TableView::FIXED:
1300       {
1301         item["policy"] = fixedPolicy;
1302         item["value"]  = dataInstance.size;
1303         break;
1304       }
1305       case Toolkit::TableView::RELATIVE:
1306       {
1307         item["policy"] = relativePolicy;
1308         item["value"]  = dataInstance.fillRatio;
1309         break;
1310       }
1311       case Toolkit::TableView::FIT:
1312       {
1313         item["policy"] = fitPolicy;
1314         item["value"]  = 0.f;
1315         break;
1316       }
1317       case Toolkit::TableView::FILL:
1318       default:
1319       {
1320         item["policy"] = fillPolicy;
1321         item["value"]  = 0.f;
1322         break;
1323       }
1324     }
1325     std::ostringstream ss;
1326     ss << i;
1327     map[ss.str()] = item;
1328   }
1329 }
1330
1331 TableView::~TableView()
1332 {
1333   // nothing to do
1334 }
1335
1336 Actor TableView::GetNextKeyboardFocusableActor(Actor currentFocusedActor, Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
1337 {
1338   Actor nextFocusableActor;
1339
1340   if(!currentFocusedActor)
1341   {
1342     // Nothing is currently focused, so the child in the first cell should be focused.
1343     nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(0, 0));
1344   }
1345   else
1346   {
1347     Toolkit::TableView::CellPosition position;
1348     if(FindChildPosition(currentFocusedActor, position))
1349     {
1350       // The current focused actor is a child of TableView
1351       bool focusLost       = false;
1352       int  currentRow      = position.rowIndex;
1353       int  currentColumn   = position.columnIndex;
1354       int  numberOfColumns = GetColumns();
1355       int  numberOfRows    = GetRows();
1356
1357       bool  lastCell = false;
1358       Actor nextValidActor;
1359
1360       switch(direction)
1361       {
1362         case Toolkit::Control::KeyboardFocus::LEFT:
1363         {
1364           do
1365           {
1366             if(--currentColumn < 0)
1367             {
1368               currentColumn = numberOfColumns - 1;
1369               if(--currentRow < 0)
1370               {
1371                 lastCell   = true;
1372                 currentRow = loopEnabled ? numberOfRows - 1 : 0;
1373                 focusLost  = (currentRow == 0);
1374               }
1375             }
1376             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1377           } while(!nextValidActor && !lastCell);
1378           break;
1379         }
1380         case Toolkit::Control::KeyboardFocus::RIGHT:
1381         {
1382           do
1383           {
1384             if(++currentColumn > numberOfColumns - 1)
1385             {
1386               currentColumn = 0;
1387               if(++currentRow > numberOfRows - 1)
1388               {
1389                 lastCell   = true;
1390                 currentRow = loopEnabled ? 0 : numberOfRows - 1;
1391                 focusLost  = (currentRow == numberOfRows - 1);
1392               }
1393             }
1394             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1395           } while(!nextValidActor && !lastCell);
1396           break;
1397         }
1398         case Toolkit::Control::KeyboardFocus::UP:
1399         {
1400           do
1401           {
1402             if(--currentRow < 0)
1403             {
1404               lastCell   = true;
1405               currentRow = loopEnabled ? numberOfRows - 1 : 0;
1406               focusLost  = (currentRow == 0);
1407             }
1408             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1409           } while(!nextValidActor && !lastCell);
1410           break;
1411         }
1412         case Toolkit::Control::KeyboardFocus::DOWN:
1413
1414         {
1415           do
1416           {
1417             if(++currentRow > numberOfRows - 1)
1418             {
1419               lastCell   = true;
1420               currentRow = loopEnabled ? 0 : numberOfRows - 1;
1421               focusLost  = (currentRow == numberOfRows - 1);
1422             }
1423             nextValidActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1424           } while(!nextValidActor && !lastCell);
1425           break;
1426         }
1427         default:
1428         {
1429           break;
1430         }
1431       }
1432
1433       // Move the focus if we haven't lost it.
1434       if(!focusLost)
1435       {
1436         nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(currentRow, currentColumn));
1437
1438         // Save the focused actor in the TableView.
1439         mPreviousFocusedActor = nextFocusableActor;
1440       }
1441     }
1442     else
1443     {
1444       // The current focused actor is not within this TableView.
1445
1446       unsigned int numberOfColumns = GetColumns();
1447       unsigned int numberOfRows    = GetRows();
1448
1449       // Check whether the previous focused actor is a focus group (i.e. a layout container)
1450       bool  wasFocusedOnLayoutContainer = false;
1451       Actor previousFocusedActor        = mPreviousFocusedActor.GetHandle();
1452       if(previousFocusedActor)
1453       {
1454         Toolkit::Control control = Toolkit::Control::DownCast(previousFocusedActor);
1455         if(control)
1456         {
1457           Internal::Control& controlImpl = static_cast<Internal::Control&>(control.GetImplementation());
1458           wasFocusedOnLayoutContainer    = controlImpl.IsKeyboardFocusGroup();
1459         }
1460       }
1461
1462       // Check whether the previous focused actor is a layout container and also a child of this TableView
1463       Toolkit::TableView::CellPosition position;
1464       if(wasFocusedOnLayoutContainer && FindChildPosition(previousFocusedActor, position))
1465       {
1466         nextFocusableActor = GetNextKeyboardFocusableActor(previousFocusedActor, direction, loopEnabled);
1467       }
1468       else
1469       {
1470         // Otherwise, move the focus to either the first or the last cell according to the given direction.
1471         if(direction == Toolkit::Control::KeyboardFocus::LEFT || direction == Toolkit::Control::KeyboardFocus::UP)
1472         {
1473           nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(numberOfRows - 1, numberOfColumns - 1));
1474         }
1475         else
1476         {
1477           nextFocusableActor = GetChildAt(Toolkit::TableView::CellPosition(0, 0));
1478         }
1479       }
1480     }
1481   }
1482
1483   return nextFocusableActor;
1484 }
1485
1486 Vector3 TableView::GetNaturalSize()
1487 {
1488   // Natural size is the size of all fixed cell widths or heights. This ignores cells with relative heights.
1489   return Vector3(mFixedTotals.width, mFixedTotals.height, 1.0f);
1490 }
1491
1492 float TableView::CalculateChildSize(const Actor& child, Dimension::Type dimension)
1493 {
1494   Toolkit::TableView::CellPosition position;
1495   if(FindChildPosition(child, position))
1496   {
1497     switch(dimension)
1498     {
1499       case Dimension::WIDTH:
1500       {
1501         float cellSize = 0.0f;
1502         cellSize       = mColumnData[position.columnIndex + position.columnSpan - 1].position - (position.columnIndex > 0 ? mColumnData[position.columnIndex - 1].position : 0.f) - mPadding.width * 2.0f;
1503
1504         if(cellSize < 0.0f)
1505         {
1506           cellSize = 0.0f;
1507         }
1508
1509         return cellSize;
1510       }
1511
1512       case Dimension::HEIGHT:
1513       {
1514         float cellSize = 0.0f;
1515
1516         cellSize = mRowData[position.rowIndex + position.rowSpan - 1].position - (position.rowIndex > 0 ? mRowData[position.rowIndex - 1].position : 0.f) - mPadding.height * 2.0f;
1517
1518         if(cellSize < 0.0f)
1519         {
1520           cellSize = 0.0f;
1521         }
1522
1523         return cellSize;
1524       }
1525       default:
1526       {
1527         return 0.0f;
1528       }
1529     }
1530   }
1531
1532   return 0.0f; // Child not found
1533 }
1534
1535 bool TableView::RelayoutDependentOnChildren(Dimension::Type dimension)
1536 {
1537   if(Control::RelayoutDependentOnChildren(dimension))
1538   {
1539     return true;
1540   }
1541
1542   return FindFit(mRowData) || FindFit(mColumnData);
1543 }
1544
1545 void TableView::SetCellAlignment(Toolkit::TableView::CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical)
1546 {
1547   // Check if we need to expand our data array
1548   if(position.rowIndex >= mCellData.GetRows())
1549   {
1550     // Only adding new rows
1551     ResizeContainers(position.rowIndex + 1, mCellData.GetColumns());
1552   }
1553
1554   if(position.columnIndex >= mCellData.GetColumns())
1555   {
1556     // Only adding new columns
1557     ResizeContainers(mCellData.GetRows(), position.columnIndex + 1);
1558   }
1559
1560   // Set the alignment of the cell
1561   CellData& data           = mCellData[position.rowIndex][position.columnIndex];
1562   data.horizontalAlignment = horizontal;
1563   data.verticalAlignment   = vertical;
1564 }
1565
1566 void TableView::CalculateFillSizes(RowColumnArray& data)
1567 {
1568   // First pass: Count number of fill entries and calculate used relative space
1569   Dali::Vector<RowColumnData*> fillData;
1570   float                        relativeTotal = 0.0f;
1571
1572   const unsigned int dataCount = data.Size();
1573
1574   for(unsigned int i = 0; i < dataCount; ++i)
1575   {
1576     RowColumnData& dataInstance = data[i];
1577
1578     if(dataInstance.sizePolicy == Toolkit::TableView::RELATIVE)
1579     {
1580       relativeTotal += dataInstance.fillRatio;
1581     }
1582     else if(dataInstance.sizePolicy == Toolkit::TableView::FILL)
1583     {
1584       fillData.PushBack(&dataInstance);
1585     }
1586   }
1587
1588   // Second pass: Distribute remaining relative space
1589   const unsigned int fillCount = fillData.Size();
1590   if(fillCount > 0)
1591   {
1592     if(relativeTotal > 1.0f)
1593     {
1594       relativeTotal = 1.0f;
1595     }
1596
1597     const float evenFillRatio = (1.0f - relativeTotal) / fillCount;
1598
1599     for(unsigned int i = 0; i < fillCount; ++i)
1600     {
1601       fillData[i]->fillRatio = evenFillRatio;
1602     }
1603   }
1604 }
1605
1606 float TableView::CalculateTotalFixedSize(const RowColumnArray& data)
1607 {
1608   float totalSize = 0.0f;
1609
1610   const unsigned int dataCount = data.Size();
1611
1612   for(unsigned int i = 0; i < dataCount; ++i)
1613   {
1614     const RowColumnData& dataInstance = data[i];
1615
1616     switch(dataInstance.sizePolicy)
1617     {
1618       // we have absolute size to FIXED and FIT column/row and relative size for RELATIVE and FILL column/row
1619       case Toolkit::TableView::FIXED:
1620       case Toolkit::TableView::FIT:
1621       {
1622         totalSize += dataInstance.size;
1623         break;
1624       }
1625
1626       default:
1627       {
1628         break;
1629       }
1630     }
1631   }
1632
1633   return totalSize;
1634 }
1635
1636 Vector2 TableView::GetCellPadding(Dimension::Type dimension)
1637 {
1638   switch(dimension)
1639   {
1640     case Dimension::WIDTH:
1641     {
1642       return Vector2(mPadding.x, mPadding.x);
1643     }
1644     case Dimension::HEIGHT:
1645     {
1646       return Vector2(mPadding.y, mPadding.y);
1647     }
1648     default:
1649     {
1650       break;
1651     }
1652   }
1653
1654   return Vector2();
1655 }
1656
1657 void TableView::CalculateFitSizes(RowColumnArray& data, Dimension::Type dimension)
1658 {
1659   Vector2 cellPadding = GetCellPadding(dimension);
1660
1661   const unsigned int dataCount = data.Size();
1662
1663   for(unsigned int i = 0; i < dataCount; ++i)
1664   {
1665     RowColumnData& dataInstance = data[i];
1666
1667     if(dataInstance.sizePolicy == Toolkit::TableView::FIT)
1668     {
1669       // Find the size of the biggest actor in the row or column
1670       float maxActorHeight = 0.0f;
1671
1672       unsigned int fitCount = (dimension == Dimension::WIDTH) ? mCellData.GetRows() : mCellData.GetColumns();
1673
1674       for(unsigned int j = 0; j < fitCount; ++j)
1675       {
1676         unsigned int row    = (dimension == Dimension::WIDTH) ? j : i;
1677         unsigned int column = (dimension == Dimension::WIDTH) ? i : j;
1678         DALI_ASSERT_DEBUG(row < mCellData.GetRows());
1679         DALI_ASSERT_DEBUG(column < mCellData.GetColumns());
1680
1681         const CellData& cellData = mCellData[row][column];
1682         const Actor&    actor    = cellData.actor;
1683         if(actor)
1684         {
1685           if(FitToChild(actor, dimension) && (dimension == Dimension::WIDTH) ? (cellData.position.columnSpan == 1) : (cellData.position.rowSpan == 1))
1686           {
1687             maxActorHeight = std::max(maxActorHeight, actor.GetRelayoutSize(dimension) + cellPadding.x + cellPadding.y);
1688           }
1689         }
1690       }
1691
1692       dataInstance.size = maxActorHeight;
1693     }
1694   }
1695 }
1696
1697 bool TableView::FindFit(const RowColumnArray& data)
1698 {
1699   for(unsigned int i = 0, count = data.Size(); i < count; ++i)
1700   {
1701     if(data[i].sizePolicy == Toolkit::TableView::FIT)
1702     {
1703       return true;
1704     }
1705   }
1706
1707   return false;
1708 }
1709
1710 } // namespace Internal
1711
1712 } // namespace Toolkit
1713
1714 } // namespace Dali