System Clipboard shown and items can be pasted
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / controls / table-view / table-view.h
1 #ifndef __DALI_TOOLKIT_TABLE_VIEW_H__
2 #define __DALI_TOOLKIT_TABLE_VIEW_H__
3
4 /*
5  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
6  *
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
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
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.
18  *
19  */
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/common/vector-wrapper.h>
23 #include <dali/public-api/actors/actor-enumerations.h>
24
25 // INTERNAL INCLUDES
26 #include <dali-toolkit/public-api/controls/control.h>
27
28 namespace Dali
29 {
30
31 namespace Toolkit
32 {
33
34 namespace Internal DALI_INTERNAL
35 {
36 class TableView;
37 }
38
39 /**
40  * TableView is a layout container for aligning child actors in a grid like layout.
41  * TableView constrains the x and y position and width and height of the child actors.
42  * z position and depth are left intact so that 3D model actors can also be laid out
43  * in a grid without loosing their depth scaling.
44  *
45  * @nosubgrouping
46  *
47  * Per-child Custom properties for script supporting.
48  *
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
51  *
52  * These properties are registered dynamically to the child and is non-animatable.
53  *
54  * | %Property Name            | Type               |
55  * |---------------------------|--------------------|
56  * | cell-index                | Vector2            |
57  * | row-span                  | float              | // type float (Currently builder is unable to differentiate integer and float from Json string)
58  * | column-span               | float              | // type float (Currently builder is unable to differentiate integer and float from Json string)
59  * | cell-horizontal-alignment | string             | // available values: left, center, right
60  * | cell-vertical-alignment   | string             | // available values: top, center, bottom
61  *
62  * @code
63  * "name":"gallery-1",
64  * "type":"ImageActor",
65  * "image": {
66  *    "filename": "{DALI_IMAGE_DIR}gallery-small-1.jpg"
67  *  },
68  *  "custom-properties": {
69  *     "cell-index":[1,1],  // property to specify the top-left cell this child occupies, if not set, the first available cell is used
70  *     "row-span":3,        // property to specify how many rows this child occupies, if not set, default value is 1
71  *     "column-span": 2,    // property to specify how many columns this child occupies, if nor set, default value is 1
72  *     "cell-horizontal-alignment": "left", // property to specify how to align horizontally inside the cells, if not set, default value is 'left'
73  *     "cell-vertical-alignment": "center"  // property to specify how to align vertically inside the cells, if not set, default value is 'top'
74  *   }
75  * @endcode
76  */
77 class DALI_IMPORT_API TableView : public Control
78 {
79 public:
80
81   /**
82    * @brief The start and end property ranges for this control.
83    */
84   enum PropertyRange
85   {
86     PROPERTY_START_INDEX = Control::CONTROL_PROPERTY_END_INDEX + 1,
87     PROPERTY_END_INDEX =   PROPERTY_START_INDEX + 1000              ///< Reserve property indices
88   };
89
90   /**
91    * @brief An enumeration of properties belonging to the TableView class.
92    *
93    * LayoutRows: set the height of the rows.
94    * It has the format as follows in script:
95    * @code
96    * "layout-rows":
97       {
98         "0": { "policy": "fixed", "value": 40 },       //@see SetFixedHight
99         "2": { "policy": "relative", "value": 0.33 },  //@see SetRelativeHeight
100         "3": { "policy": "fit", "value":0.0 }          //@see SetFitHeight, the value is not used, its height is decided by the children in this row
101       }
102    * @endcode
103    *
104    * LayoutColumns: set the height of the rows.
105    * It has the format as follows in script:
106    * @code
107    * "layout-columns":
108       {
109         "0": { "policy": "fixed", "value": 40 },       //@see SetFixedWidth
110         "1": { "policy": "fit", "value":0.0 }          //@see SetFitHeight, the value is not used, its width is decided by the children in this column
111         "2": { "policy": "relative", "value": 0.33 }   //@see SetRelativeWidth
112       }
113    * @endcode
114    */
115   struct Property
116   {
117     enum
118     {
119       ROWS = PROPERTY_START_INDEX, ///< name "rows",           type unsigned int
120       COLUMNS,                     ///< name "columns",        type unsigned int
121       CELL_PADDING,                ///< name "cell-padding",   type Vector2
122       LAYOUT_ROWS,                 ///< name "layout-rows",    type Map
123       LAYOUT_COLUMNS,              ///< name "layout-columns", type Map
124     };
125   };
126
127   /**
128    * @brief Describes how the size of a row / column been set
129    */
130   enum LayoutPolicy
131   {
132     FIXED,      ///< Fixed with the given value.
133     RELATIVE,   ///< Calculated as percentage of the remainder after subtracting Padding and Fixed height/width
134     FILL,       ///< Default policy, get the remainder of the 100% (after subtracting Padding, Fixed and Relative height/ width) divided evenly between 'fill' rows/columns
135     FIT         ///< Fit around its children.
136   };
137
138   /**
139    * Structure to specify layout position for child actor
140    */
141   struct CellPosition
142   {
143     /**
144      * Constructor to initialise values to defaults for convenience
145      */
146     CellPosition( unsigned int rowIndex = 0, unsigned int columnIndex = 0,
147                     unsigned int rowSpan = 1, unsigned int columnSpan = 1 )
148     : rowIndex( rowIndex ), columnIndex( columnIndex ),
149       rowSpan( rowSpan ), columnSpan( columnSpan )
150     { }
151
152     unsigned int rowIndex;
153     unsigned int columnIndex;
154     unsigned int rowSpan;
155     unsigned int columnSpan;
156   };
157
158   /**
159    * Create a TableView handle; this can be initialised with TableView::New()
160    * Calling member functions with an uninitialised handle is not allowed.
161    */
162   TableView();
163
164   /**
165    * Copy constructor. Creates another handle that points to the same real object
166    * @param handle to copy from
167    */
168   TableView( const TableView& handle );
169
170   /**
171    * Assignment operator. Changes this handle to point to another real object
172    */
173   TableView& operator=( const TableView& handle );
174
175   /**
176    * @brief Destructor
177    *
178    * This is non-virtual since derived Handle types must not contain data or virtual methods.
179    */
180   ~TableView();
181
182   /**
183    * Create the TableView control.
184    * @param[in] initialRows for the table
185    * @param[in] initialColumns for the table
186    * @return A handle to the TableView control.
187    */
188   static TableView New( unsigned int initialRows, unsigned int initialColumns );
189
190   /**
191    * Downcast an Object handle to TableView. If handle points to a TableView the
192    * downcast produces valid handle. If not the returned handle is left uninitialized.
193    * @param[in] handle Handle to an object
194    * @return handle to a TableView or an uninitialized handle
195    */
196   static TableView DownCast( BaseHandle handle );
197
198   /**
199    * Adds a child to the table
200    * If the row or column index is outside the table, the table gets resized bigger
201    * @pre The child actor has been initialized.
202    * @param[in] child to add
203    * @param[in] position for the child
204    * @return true if the addition succeeded, false if the cell is already occupied
205    */
206   bool AddChild( Actor child, CellPosition position );
207
208   /**
209    * Returns a child from the given layout position
210    * Note! if there is no child in this position this method returns an uninitialized
211    * Actor handle
212    * @param[in] position in the table
213    * @return child that was in the cell or an uninitialized handle
214    */
215   Actor GetChildAt( CellPosition position );
216
217   /**
218    * Removes a child from the given layout position
219    * Note! if there is no child in this position this method does nothing
220    * @param[in] position for the child to remove
221    * @return child that was removed or an uninitialized handle
222    */
223   Actor RemoveChildAt( CellPosition position );
224
225   /**
226    * Finds the childs layout position
227    * @param[in] child to search for
228    * @param[out] position for the child
229    * @return true if the child was included in this TableView
230    */
231   bool FindChildPosition( Actor child, CellPosition& position );
232
233   /**
234    * Insert a new row to given index
235    * @param [in] rowIndex of the new row
236    */
237   void InsertRow( unsigned int rowIndex );
238
239   /**
240    * Delete a row from given index
241    * Removed elements are deleted
242    * @param [in] rowIndex of the row to delete
243    */
244   void DeleteRow( unsigned int rowIndex );
245
246   /**
247    * Delete a row from given index
248    * @param [in] rowIndex of the row to delete
249    * @param [out] removed elements
250    */
251   void DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed );
252
253   /**
254    * Insert a new column to given index
255    * @param [in] columnIndex of the new column
256    */
257   void InsertColumn( unsigned int columnIndex );
258
259   /**
260    * Delete a column from given index.
261    * Removed elements are deleted
262    * @param [in] columnIndex of the column to delete
263    */
264   void DeleteColumn( unsigned int columnIndex );
265
266   /**
267    * Delete a column from given index
268    * @param [in] columnIndex of the column to delete
269    * @param [out] removed elements
270    */
271   void DeleteColumn( unsigned int columnIndex, std::vector<Actor>& removed );
272
273   /**
274    * Resize the TableView. Note! if the new size is smaller than old,
275    * superfluous actors get removed. If you want to relayout removed children,
276    * use the variant that returns the removed Actors and reinsert them into the table
277    * If an actor spans to a removed row or column it gets removed from the table
278    * @param[in] rows for the table
279    * @param[in] columns for the table
280    */
281   void Resize( unsigned int rows, unsigned int columns );
282
283   /**
284    * Resize the TableView. Note! if the new size is smaller than old,
285    * superfluous actors get removed.
286    * If an actor spans to a removed row or column it gets removed from the table
287    * @param[in] rows for the table
288    * @param[in] columns for the table
289    * @param[out] removed actor handles
290    */
291   void Resize( unsigned int rows, unsigned int columns, std::vector<Actor>& removed );
292
293   /**
294    * Set horizontal and vertical padding between cells
295    * @param[in] padding width and height
296    */
297   void SetCellPadding( Size padding );
298
299   /**
300    * @return the current padding as width and height
301    */
302   Size GetCellPadding();
303
304   /**
305    * @brief Specify this row as fitting its height to its children
306    *
307    * @param[in] rowIndex The row to set
308    */
309   void SetFitHeight( unsigned int rowIndex );
310
311   /**
312    * @brief Is the row a fit row
313    *
314    * @param[in] rowIndex The row to check
315    * @return Return true if the row is fit
316    */
317   bool IsFitHeight( unsigned int rowIndex ) const;
318
319   /**
320    * @brief Specify this column as fitting its width to its children
321    *
322    * @param[in] columnIndex The column to set
323    */
324   void SetFitWidth( unsigned int columnIndex );
325
326   /**
327    * @brief Is the column a fit column
328    *
329    * @param[in] columnIndex The column to check
330    * @return Return true if the column is fit
331    */
332   bool IsFitWidth( unsigned int columnIndex ) const;
333
334   /**
335    * Sets a row to have fixed height
336    * Setting a fixed height of 0 has no effect
337    * @pre The row rowIndex must exist.
338    * @param rowIndex for row with fixed height
339    * @param height in world coordinate units
340    */
341   void SetFixedHeight( unsigned int rowIndex, float height );
342
343   /**
344    * Gets a row's fixed height.
345    * Note! The returned value is valid if it has been set before.
346    * @pre The row rowIndex must exist.
347    * @return height in world coordinate units.
348    */
349   float GetFixedHeight( unsigned int rowIndex ) const;
350
351   /**
352    * Sets a row to have relative height. Relative height means percentage of
353    * the remainder of the table height after subtracting Padding and Fixed height rows
354    * Setting a relative height of 0 has no effect
355    * @pre The row rowIndex must exist.
356    * @param rowIndex for row with relative height
357    * @param heightPercentage between 0.0f and 1.0f
358    */
359   void SetRelativeHeight( unsigned int rowIndex, float heightPercentage );
360
361   /**
362    * Gets a row's relative height.
363    * Note! The returned value is valid if it has been set before.
364    * @pre The row rowIndex must exist.
365    * @return height in percentage units, between 0.0f and 1.0f.
366    */
367   float GetRelativeHeight( unsigned int rowIndex ) const;
368
369   /**
370    * Sets a column to have fixed width
371    * Setting a fixed width of 0 has no effect
372    * @pre The column columnIndex must exist.
373    * @param columnIndex for column with fixed width
374    * @param width in world coordinate units
375    */
376   void SetFixedWidth( unsigned int columnIndex, float width );
377
378   /**
379    * Gets a column's fixed width.
380    * Note! The returned value is valid if it has been set before.
381    * @pre The column columnIndex must exist.
382    * @return width in world coordinate units.
383    */
384   float GetFixedWidth( unsigned int columnIndex ) const;
385
386   /**
387    * Sets a column to have relative width. Relative width means percentage of
388    * the remainder of table width after subtracting Padding and Fixed width columns
389    * Setting a relative width of 0 has no effect
390    * @pre The column columnIndex must exist.
391    * @param columnIndex for column with fixed width
392    * @param widthPercentage between 0.0f and 1.0f
393    */
394   void SetRelativeWidth( unsigned int columnIndex, float widthPercentage );
395
396   /**
397    * Gets a column's relative width.
398    * Note! The returned value is valid if it has been set before.
399    * @pre The column columnIndex must exist.
400    * @return width in percentage units, between 0.0f and 1.0f.
401    */
402   float GetRelativeWidth( unsigned int columnIndex ) const;
403
404   /**
405    * @return the amount of rows in the table
406    */
407   unsigned int GetRows();
408
409   /**
410    * @return the amount of columns in the table
411    */
412   unsigned int GetColumns();
413
414   /**
415    * @brief Set the alignment on a cell.
416    *
417    * Cells without calling this function have the default values of LEFT and TOP respectively.
418    *
419    * @param[in] position The cell to set alignment on.
420    * @param[in] horizontal The horizontal alignment.
421    * @param[in] vertical The vertical alignment.
422    */
423   void SetCellAlignment( CellPosition position, HorizontalAlignment::Type horizontal, VerticalAlignment::Type vertical );
424
425 public: // Not intended for application developers
426
427   /**
428    * Creates a handle using the Toolkit::Internal implementation.
429    * @param[in]  implementation  The Control implementation.
430    */
431   DALI_INTERNAL TableView(Internal::TableView& implementation);
432
433   /**
434    * Allows the creation of this Control from an Internal::CustomActor pointer.
435    * @param[in]  internal  A pointer to the internal CustomActor.
436    */
437   explicit DALI_INTERNAL TableView( Dali::Internal::CustomActor* internal );
438 };
439
440 } // namespace Toolkit
441
442 } // namespace Dali
443
444 #endif // __DALI_TOOLKIT_TABLE_VIEW_H__