[dali_2.0.25] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / 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