1 #ifndef __DALI_TOOLKIT_TABLE_VIEW_H__
2 #define __DALI_TOOLKIT_TABLE_VIEW_H__
5 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
22 #include <dali/public-api/common/vector-wrapper.h>
23 #include <dali/public-api/actors/actor-enumerations.h>
26 #include <dali-toolkit/public-api/controls/control.h>
34 namespace Internal DALI_INTERNAL
40 * @brief TableView is a layout container for aligning child actors in a grid like layout.
42 * TableView constrains the x and y position and width and height of the child actors.
43 * z position and depth are left intact so that 3D model actors can also be laid out
44 * in a grid without loosing their depth scaling.
47 * <h3>Per-child Custom properties for script supporting:</h3>
49 * When an actor is add to the tableView through Actor::Add() instead of TableView::AddChild,
50 * the following custom properties of the actor are checked to decide the actor position inside the table.
52 * These properties are registered dynamically to the child and is non-animatable.
54 * | %Property Name | Type |
55 * |---------------------------|-------------|
56 * | cell-index | Vector2 |
57 * | row-span | float |
58 * | column-span | float |
59 * | cell-horizontal-alignment | string |
60 * | cell-vertical-alignment | string |
62 * The row-span or column span has integer value, but its type is float here due to the limitation of the builder's ability to differentiate integer and float from Json string.
63 * The available values for cell-horizontal-alignment are: left, center, right.
64 * The available values for cell-vertical-alignment are: top, center, bottom.
68 * "type":"ImageActor",
70 * "filename": "{DALI_IMAGE_DIR}gallery-small-1.jpg"
72 * "custom-properties": {
73 * "cell-index":[1,1], // property to specify the top-left cell this child occupies, if not set, the first available cell is used
74 * "row-span":3, // property to specify how many rows this child occupies, if not set, default value is 1
75 * "column-span": 2, // property to specify how many columns this child occupies, if nor set, default value is 1
76 * "cell-horizontal-alignment": "left", // property to specify how to align horizontally inside the cells, if not set, default value is 'left'
77 * "cell-vertical-alignment": "center" // property to specify how to align vertically inside the cells, if not set, default value is 'top'
81 class DALI_IMPORT_API TableView : public Control
86 * @brief The start and end property ranges for this control.
90 PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
91 PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000 ///< Reserve property indices
95 * @brief An enumeration of properties belonging to the TableView class.
97 * LayoutRows: set the height of the rows.
98 * It has the format as follows in script:
102 "0": { "policy": "fixed", "value": 40 }, //@see SetFixedHight
103 "2": { "policy": "relative", "value": 0.33 }, //@see SetRelativeHeight
104 "3": { "policy": "fit", "value":0.0 } //@see SetFitHeight, the value is not used, its height is decided by the children in this row
108 * LayoutColumns: set the height of the rows.
109 * It has the format as follows in script:
113 "0": { "policy": "fixed", "value": 40 }, //@see SetFixedWidth
114 "1": { "policy": "fit", "value":0.0 } //@see SetFitHeight, the value is not used, its width is decided by the children in this column
115 "2": { "policy": "relative", "value": 0.33 } //@see SetRelativeWidth
123 ROWS = PROPERTY_START_INDEX, ///< name "rows", type unsigned int
124 COLUMNS, ///< name "columns", type unsigned int
125 CELL_PADDING, ///< name "cell-padding", type Vector2
126 LAYOUT_ROWS, ///< name "layout-rows", type Map
127 LAYOUT_COLUMNS, ///< name "layout-columns", type Map
132 * @brief Describes how the size of a row / column been set
136 FIXED, ///< Fixed with the given value.
137 RELATIVE, ///< Calculated as percentage of the remainder after subtracting Padding and Fixed height/width
138 FILL, ///< Default policy, get the remainder of the 100% (after subtracting Fixed, Fit and Relative height/ width) divided evenly between 'fill' rows/columns
139 FIT ///< Fit around its children.
143 * Structure to specify layout position for child actor
148 * Constructor to initialise values to defaults for convenience
150 CellPosition( unsigned int rowIndex = 0, unsigned int columnIndex = 0,
151 unsigned int rowSpan = 1, unsigned int columnSpan = 1 )
152 : rowIndex( rowIndex ), columnIndex( columnIndex ),
153 rowSpan( rowSpan ), columnSpan( columnSpan )
156 unsigned int rowIndex;
157 unsigned int columnIndex;
158 unsigned int rowSpan;
159 unsigned int columnSpan;
163 * Create a TableView handle; this can be initialised with TableView::New()
164 * Calling member functions with an uninitialised handle is not allowed.
169 * Copy constructor. Creates another handle that points to the same real object
170 * @param handle to copy from
172 TableView( const TableView& handle );
175 * Assignment operator. Changes this handle to point to another real object
177 TableView& operator=( const TableView& handle );
182 * This is non-virtual since derived Handle types must not contain data or virtual methods.
187 * Create the TableView control.
188 * @param[in] initialRows for the table
189 * @param[in] initialColumns for the table
190 * @return A handle to the TableView control.
192 static TableView New( unsigned int initialRows, unsigned int initialColumns );
195 * Downcast an Object handle to TableView. If handle points to a TableView the
196 * downcast produces valid handle. If not the returned handle is left uninitialized.
197 * @param[in] handle Handle to an object
198 * @return handle to a TableView or an uninitialized handle
200 static TableView DownCast( BaseHandle handle );
203 * Adds a child to the table
204 * If the row or column index is outside the table, the table gets resized bigger
205 * @pre The child actor has been initialized.
206 * @param[in] child to add
207 * @param[in] position for the child
208 * @return true if the addition succeeded, false if the cell is already occupied
210 bool AddChild( Actor child, CellPosition position );
213 * Returns a child from the given layout position
214 * Note! if there is no child in this position this method returns an uninitialized
216 * @param[in] position in the table
217 * @return child that was in the cell or an uninitialized handle
219 Actor GetChildAt( CellPosition position );
222 * Removes a child from the given layout position
223 * Note! if there is no child in this position this method does nothing
224 * @param[in] position for the child to remove
225 * @return child that was removed or an uninitialized handle
227 Actor RemoveChildAt( CellPosition position );
230 * Finds the childs layout position
231 * @param[in] child to search for
232 * @param[out] position for the child
233 * @return true if the child was included in this TableView
235 bool FindChildPosition( Actor child, CellPosition& position );
238 * Insert a new row to given index
239 * @param [in] rowIndex of the new row
241 void InsertRow( unsigned int rowIndex );
244 * Delete a row from given index
245 * Removed elements are deleted
246 * @param [in] rowIndex of the row to delete
248 void DeleteRow( unsigned int rowIndex );
251 * Delete a row from given index
252 * @param [in] rowIndex of the row to delete
253 * @param [out] removed elements
255 void DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed );
258 * Insert a new column to given index
259 * @param [in] columnIndex of the new column
261 void InsertColumn( unsigned int columnIndex );
264 * Delete a column from given index.
265 * Removed elements are deleted
266 * @param [in] columnIndex of the column to delete
268 void DeleteColumn( unsigned int columnIndex );
271 * Delete a column from given index
272 * @param [in] columnIndex of the column to delete
273 * @param [out] removed elements
275 void DeleteColumn( unsigned int columnIndex, std::vector<Actor>& removed );
278 * Resize the TableView. Note! if the new size is smaller than old,
279 * superfluous actors get removed. If you want to relayout removed children,
280 * use the variant that returns the removed Actors and reinsert them into the table
281 * If an actor spans to a removed row or column it gets removed from the table
282 * @param[in] rows for the table
283 * @param[in] columns for the table
285 void Resize( unsigned int rows, unsigned int columns );
288 * Resize the TableView. Note! if the new size is smaller than old,
289 * superfluous actors get removed.
290 * If an actor spans to a removed row or column it gets removed from the table
291 * @param[in] rows for the table
292 * @param[in] columns for the table
293 * @param[out] removed actor handles
295 void Resize( unsigned int rows, unsigned int columns, std::vector<Actor>& removed );
298 * Set horizontal and vertical padding between cells
299 * @param[in] padding width and height
301 void SetCellPadding( Size padding );
304 * @return the current padding as width and height
306 Size GetCellPadding();
309 * @brief Specify this row as fitting its height to its children
311 * @param[in] rowIndex The row to set
313 void SetFitHeight( unsigned int rowIndex );
316 * @brief Is the row a fit row
318 * @param[in] rowIndex The row to check
319 * @return Return true if the row is fit
321 bool IsFitHeight( unsigned int rowIndex ) const;
324 * @brief Specify this column as fitting its width to its children
326 * @param[in] columnIndex The column to set
328 void SetFitWidth( unsigned int columnIndex );
331 * @brief Is the column a fit column
333 * @param[in] columnIndex The column to check
334 * @return Return true if the column is fit
336 bool IsFitWidth( unsigned int columnIndex ) const;
339 * Sets a row to have fixed height
340 * Setting a fixed height of 0 has no effect
341 * @pre The row rowIndex must exist.
342 * @param rowIndex for row with fixed height
343 * @param height in world coordinate units
345 void SetFixedHeight( unsigned int rowIndex, float height );
348 * Gets a row's fixed height.
349 * Note! The returned value is valid if it has been set before.
350 * @pre The row rowIndex must exist.
351 * @return height in world coordinate units.
353 float GetFixedHeight( unsigned int rowIndex ) const;
356 * Sets a row to have relative height. Relative height means percentage of
357 * the remainder of the table height after subtracting Padding and Fixed height rows
358 * Setting a relative height of 0 has no effect
359 * @pre The row rowIndex must exist.
360 * @param rowIndex for row with relative height
361 * @param heightPercentage between 0.0f and 1.0f
363 void SetRelativeHeight( unsigned int rowIndex, float heightPercentage );
366 * Gets a row's relative height.
367 * Note! The returned value is valid if it has been set before.
368 * @pre The row rowIndex must exist.
369 * @return height in percentage units, between 0.0f and 1.0f.
371 float GetRelativeHeight( unsigned int rowIndex ) const;
374 * Sets a column to have fixed width
375 * Setting a fixed width of 0 has no effect
376 * @pre The column columnIndex must exist.
377 * @param columnIndex for column with fixed width
378 * @param width in world coordinate units
380 void SetFixedWidth( unsigned int columnIndex, float width );
383 * Gets a column's fixed width.
384 * Note! The returned value is valid if it has been set before.
385 * @pre The column columnIndex must exist.
386 * @return width in world coordinate units.
388 float GetFixedWidth( unsigned int columnIndex ) const;
391 * Sets a column to have relative width. Relative width means percentage of
392 * the remainder of table width after subtracting Padding and Fixed width columns
393 * Setting a relative width of 0 has no effect
394 * @pre The column columnIndex must exist.
395 * @param columnIndex for column with fixed width
396 * @param widthPercentage between 0.0f and 1.0f
398 void SetRelativeWidth( unsigned int columnIndex, float widthPercentage );
401 * Gets a column's relative width.
402 * Note! The returned value is valid if it has been set before.
403 * @pre The column columnIndex must exist.
404 * @return width in percentage units, between 0.0f and 1.0f.
406 float GetRelativeWidth( unsigned int columnIndex ) const;
409 * @return the amount of rows in the table
411 unsigned int GetRows();
414 * @return the amount of columns in the table
416 unsigned int GetColumns();
419 * @brief Set the alignment on a cell.
421 * Cells without calling this function have the default values of LEFT and TOP respectively.
423 * @param[in] position The cell to set alignment on.
424 * @param[in] horizontal The horizontal alignment.
425 * @param[in] vertical The vertical alignment.
427 void SetCellAlignment( CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical );
429 public: // Not intended for application developers
432 * Creates a handle using the Toolkit::Internal implementation.
433 * @param[in] implementation The Control implementation.
435 DALI_INTERNAL TableView(Internal::TableView& implementation);
438 * Allows the creation of this Control from an Internal::CustomActor pointer.
439 * @param[in] internal A pointer to the internal CustomActor.
441 explicit DALI_INTERNAL TableView( Dali::Internal::CustomActor* internal );
444 } // namespace Toolkit
448 #endif // __DALI_TOOLKIT_TABLE_VIEW_H__