1 #ifndef __DALI_TOOLKIT_ITEM_LAYOUT_H__
2 #define __DALI_TOOLKIT_ITEM_LAYOUT_H__
5 * Copyright (c) 2014 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/animation/alpha-functions.h>
23 #include <dali/public-api/common/vector-wrapper.h>
26 #include <dali-toolkit/public-api/enums.h>
27 #include <dali-toolkit/public-api/controls/control.h>
37 typedef IntrusivePtr<ItemLayout> ItemLayoutPtr; ///< Pointer to a Dali::Toolkit::ItemLayout object
39 typedef std::vector<ItemLayoutPtr> ItemLayoutContainer; ///< Container of Dali::Toolkit::ItemLayout objects
40 typedef ItemLayoutContainer::iterator ItemLayoutIter; ///< Iterator for Dali::Toolkit::ItemLayoutContainer
41 typedef ItemLayoutContainer::const_iterator ItemLayoutConstIter; ///< Const Iterator for Dali::Toolkit::ItemLayoutContainer
45 * @brief A support class for managing ranges of items.
50 * @brief Create a range of item identifiers.
52 * @param[in] beginItem The first item within the range.
53 * @param[in] endItem The past-the-end item.
55 ItemRange(unsigned int beginItem, unsigned int endItem)
62 * @brief Copy Constructor.
64 * @param[in] copy ItemRange we should copy from.
66 ItemRange(const ItemRange& copy)
73 * @brief Assignment operator.
75 * @param[in] range The Range to assign from.
76 * @return The updated range.
78 ItemRange& operator=(const ItemRange& range)
86 * @brief Test whether an item is within the range.
88 * @param[in] itemId The item identifier.
89 * @return True if the item is within the range.
91 bool Within(unsigned int itemId)
93 return itemId >= begin &&
98 * @brief Create the intersection of two ranges.
100 * @param[in] second The second range.
101 * @return The intersection.
103 ItemRange Intersection(const ItemRange& second)
105 ItemRange intersection(0u, 0u);
107 // If the ranges intersect
108 if ( (begin < second.end && end > second.begin) ||
109 (second.begin < end && second.end > begin) )
111 intersection.begin = std::max(begin, second.begin);
112 intersection.end = std::min(end, second.end);
118 unsigned int begin; ///< The start of the range
119 unsigned int end; ///< The end of the range
123 * @brief An ItemLayout describes the constraints which are imposed on items in the layout.
125 * - Potentially visible items are represented by Actors, created for ItemView by the ItemFactory.
126 * - Constraints are applied after ItemView activates a layout.
128 * An ItemLayout also describes the direction of input gestures, used to scroll through the layout.
129 * Whilst scrolling, the layout provides a range of items that are within a layout-area (3D bounding volume).
131 class ItemLayout : public RefObject
135 /// @brief Function signature of a boolean constraint
136 typedef boost::function<bool (const bool& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)> BoolFunction;
138 /// @brief Function signature of a Vector3 constraint
139 typedef boost::function<Vector3 (const Vector3& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)> Vector3Function;
141 /// @brief Function signature of a Vector4 constraint
142 typedef boost::function<Vector4 (const Vector4& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)> Vector4Function;
144 /// @brief Function signature of a Quaternion constraint
145 typedef boost::function<Quaternion (const Quaternion& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)> QuaternionFunction;
148 * @brief Virtual destructor.
150 DALI_IMPORT_API virtual ~ItemLayout();
153 * @brief Set the orientation of the layout.
155 * @param[in] orientation The orientation of the layout.
157 DALI_IMPORT_API void SetOrientation(ControlOrientation::Type orientation);
160 * @brief Query the orientation of the layout.
162 * @return the orientation of the layout.
164 DALI_IMPORT_API ControlOrientation::Type GetOrientation() const;
167 * @brief Query the minimum valid layout position; this is a negative value.
169 * When scrolling, the first item will move within the range 0 to GetMinimumLayoutPosition().
170 * @param[in] numberOfItems The current number of items in the layout.
171 * @param[in] layoutSize The size of the layout area.
172 * @return The minimum layout position.
174 virtual float GetMinimumLayoutPosition(unsigned int numberOfItems, Vector3 layoutSize) const = 0;
177 * @brief Query the closest anchor position for the given layout position.
179 * This anchor position is the position where all the items in the layout are aligned to
180 * their rounded layout positions in integer.
181 * @param[in] layoutPosition The layout position.
182 * @return The closest anchor position for the given layout position.
184 virtual float GetClosestAnchorPosition(float layoutPosition) const = 0;
187 * @brief Query the layout position for the first item in the layout to move to when the layout
188 * needs to scroll to a particular item.
190 * @param[in] itemId The ID of an item in the layout.
191 * @return The layout position for the first item in the layout to move to.
193 virtual float GetItemScrollToPosition(unsigned int itemId) const = 0;
196 * @brief Query the items within a given layout-area.
198 * @param[in] firstItemPosition The layout-position of the first item in the layout.
199 * @param[in] layoutSize The size of the layout area.
200 * @return The ID of the first & last visible item.
202 virtual ItemRange GetItemsWithinArea(float firstItemPosition, Vector3 layoutSize) const = 0;
205 * @brief Get the closest layout position to bring an item onto the screen.
207 * If the item is already fully on the screen this function will
208 * return the current layout position.
210 * This function is used by systems such as KeyboardFocusManager to
211 * bring the next focusable item into view and all layout
212 * implementations should provide their own version of this function
213 * to ensure proper functionality of internal toolkit systems.
215 * @param[in] itemID id of the item to bring within the viewable screen area
216 * @param[in] currentLayoutPosition the current layout position of the item view instance
217 * @param[in] layoutSize the current size of the item view instance
218 * @return The layout position
220 DALI_IMPORT_API virtual float GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize);
223 * @brief Query the number of items that should be reserved, for scrolling purposes.
225 * @param[in] layoutSize The size of the layout area.
226 * @return The number of extra items. ItemView will populate itself with actors within the layout-area
227 * (see GetItemsWithinArea), plus this number of additional items on either-side.
229 virtual unsigned int GetReserveItemCount(Vector3 layoutSize) const = 0;
232 * @brief Retrieve the target size of an item in the layout.
234 * @note layout-position is not provided as a parameter, since applying size constraints is not recommended.
235 * Animating to target-sizes is preferable, since this allows controls to perform layouting without constraints.
236 * @param[in] itemId The ID of an item in the layout.
237 * @param[in] layoutSize The layout size
238 * @param[out] itemSize The target size of an item, or an uninitialized value.
239 * @return Whether the item size is available or not
241 virtual bool GetItemSize(unsigned int itemId, Vector3 layoutSize, Vector3& itemSize) const = 0;
244 * @brief Retrieve the resize animation in the layout.
246 * @note This allows the layout to provide its own resize animation.
247 * @param[in] animation The resize animation, not owned by the layout
248 * @param[in] actor The actor to animate
249 * @param [in] size The target size.
250 * @param [in] durationSeconds The duration of the resizing.
252 virtual void GetResizeAnimation(Animation& animation, Actor actor, Vector3 size, float durationSeconds) const = 0;
255 * @brief Retrieve the position constraint function of an item in the layout.
257 * The constraint will be applied when the item is created or the layout is activated.
258 * @param[in] itemId The ID of an item in the layout.
259 * @param[out] constraint The position constraint function of an item, or an uninitialized function pointer.
260 * @return Whether the position constraint function of an item is available or not
262 virtual bool GetPositionConstraint(unsigned int itemId, Vector3Function& constraint) const = 0;
265 * @brief Retrieve the rotation constraint function of an item in the layout.
267 * The constraint will be applied when the item is created or the layout is activated.
268 * @param[in] itemId The ID of an item in the layout.
269 * @param[out] constraint The rotation constraint function of an item, or an uninitialized function pointer.
270 * @return Whether the rotation constraint function of an item is available or not
272 virtual bool GetRotationConstraint(unsigned int itemId, QuaternionFunction& constraint) const = 0;
275 * @brief Retrieve the scale constraint function of an item in the layout.
277 * The constraint will be applied when the item is created or the layout is activated.
278 * @param[in] itemId The ID of an item in the layout.
279 * @param[out] constraint The scale constraint function of an item, or an uninitialized function pointer.
280 * @return Whether the scale constraint function of an item is available or not
282 virtual bool GetScaleConstraint(unsigned int itemId, Vector3Function& constraint) const = 0;
285 * @brief Retrieve the color constraint function of an item in the layout.
287 * The constraint will be applied when the item is created or the layout is activated.
288 * @param[in] itemId The ID of an item in the layout.
289 * @param[out] constraint The color constraint function of an item, or an uninitialized function pointer.
290 * @return Whether the color constraint function of an item is available or not
292 virtual bool GetColorConstraint(unsigned int itemId, Vector4Function& constraint) const = 0;
295 * @brief Retrieve the visibility constraint function of an item in the layout.
297 * The constraint will be applied when the item is created or the layout is activated.
298 * @param[in] itemId The ID of an item in the layout.
299 * @param[out] constraint The visibility constraint function of an item, or an uninitialized function pointer.
300 * @return Whether the visibility constraint function of an item is available or not
302 virtual bool GetVisibilityConstraint(unsigned int itemId, BoolFunction& constraint) const = 0;
305 * @brief Query the scroll direction of the layout.
307 * When an input gesture follows this direction, the layout-position of items will be increased.
308 * If the input gesture points in the opposite direction, then the layout-positions will decrease.
309 * @return The scroll direction in degrees.
311 virtual Degree GetScrollDirection() const = 0;
314 * @brief Tells scroll components how to interpolate our logical scroll position as a screen x/y direction.
316 * Application developer wants to use -ve y, +ve x as up direction and +ve y, -ve x as down direction scroll values in a
317 * vertical scroll type effect (SpiralLayout). This means that scroll bar/overshoot indicator should be affected by y-axis.
318 * Returning (0.0f, 0.0f) for x and (0.0f, -1.0f) for y tells us that we need to use the y scroll value to move the scroll bar
319 * along y axis with y scroll of 0 starting at bottom (due to -1.0f on y), a value of (0.0f, 1.0f) on x axis mask would mean using y scroll value to move scroll bar along x axis
321 * This function is used by numerous objects such as scroll indicators and scroll overshoot indicators and all
322 * layout implementations should provide their own version of this function to ensure proper functionality of
323 * internal toolkit systems.
325 * @param[out] scrollHint Vector2 describing how x and y scroll values should be used for x-axis scrolling
327 DALI_IMPORT_API virtual void GetXAxisScrollHint(Vector2& scrollHint) const;
330 * @brief Tells scroll components how to interpolate our logical scroll position as a screen x/y direction.
332 * Application developer wants to use -ve y, +ve x as up direction and +ve y, -ve x as down direction scroll values in a
333 * vertical scroll type effect (SpiralLayout). This means that scroll bar/overshoot indicator should be affected by y-axis.
334 * Returning (0.0f, 0.0f) for x and (0.0f, -1.0f) for y tells us that we need to use the y scroll value to move the scroll bar
335 * along y axis with y scroll of 0 starting at bottom (due to -1.0f on y), a value of (0.0f, 1.0f) on x axis mask would mean using y scroll value to move scroll bar along x axis
337 * This function is used by numerous objects such as scroll indicators and scroll overshoot indicators and all
338 * layout implementations should provide their own version of this function to ensure proper functionality of
339 * internal toolkit systems.
341 * @param[out] scrollHint Vector2 describing how x and y scroll values should be used for y-axis scrolling
343 DALI_IMPORT_API virtual void GetYAxisScrollHint(Vector2& scrollHint) const;
346 * @brief Query the scroll speed factor of the layout while dragging.
348 * This factor is used by the layout to customise its scroll speed while dragging.
349 * The factor will be multiplied with the scroll distance of how many pixels in actor coordinate,
350 * and the layout position of the actors in ItemView will be moved by this result.
351 * For example, when the speed factor is 0.01, if the scroll distance is 100 pixels, the layout
352 * position of actors will be moved by 1.
353 * Therefore, the bigger the factor is, the faster the scroll speed will be.
355 * @return The scroll speed factor of the layout.
357 virtual float GetScrollSpeedFactor() const = 0;
360 * @brief Query the maximum swipe speed in pixels per second.
362 * Swipe gestures will be clamped when exceeding this speed limit.
363 * @return speed The maximum swipe speed.
365 virtual float GetMaximumSwipeSpeed() const = 0;
368 * @brief Get the duration of the flick animation in second.
370 * This is the time taken to animate each
371 * item to its next layout position (e.g. from 1.0 to 2.0) when a flick animation is triggered
372 * by a swipe gesture.
373 * @return The duration of the flick animation.
375 virtual float GetItemFlickAnimationDuration() const = 0;
378 * @brief Gets the id of the next item for KeyboardFocusManager to focus on depending on the inputted item ID.
380 * @param[in] itemID The current focused item
381 * @param[in] maxItems The maximum number of items in the list
382 * @param[in] direction The directional key pressed on the keyboard
383 * @param[in] loopEnabled Whether the KeyboardFocusManager is set to wrap around between first and last item
384 * @return The next item ID.
386 DALI_IMPORT_API virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
389 * @brief Query the flick speed factor of the layout while swipping.
391 * This factor is used by the layout to customise its scroll speed while swiping.
392 * The factor will be multiplied with the scroll distance of how many pixels in actor coordinate,
393 * and the layout position of the actors in ItemView will be moved by this result.
394 * For example, when the speed factor is 0.01, if the scroll distance is 100 pixels, the layout
395 * position of actors will be moved by 1.
396 * Therefore, the bigger the factor is, the faster the flick speed will be.
398 * @return The scroll speed factor of the layout.
400 DALI_IMPORT_API virtual float GetFlickSpeedFactor() const;
403 * @brief Applies constraints defined by the layout to an actor.
405 * @param[in] actor The actor to constrain.
406 * @param[in] itemId The ID of the item represented by the actor.
407 * @param[in] durationSeconds The time taken to fully constrain the actors.
408 * @param[in] scrollPositionObject The object which provides the layout position property.
409 * @param[in] itemViewActor The item view instance which requests the application of constraints.
411 DALI_IMPORT_API virtual void ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Handle scrollPositionObject, const Actor& itemViewActor );
414 * @brief Gets the position of a given item
416 * @param[in] itemID id of the item we want to get its position
417 * @param[in] currentLayoutPosition the current layout position of the item view instance
418 * @param[in] layoutSize the current size of the item view instance
419 * @return The item position (x,y,z)
421 DALI_IMPORT_API virtual Vector3 GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const;
424 * @brief Set the alpha function used when applying constraints
426 * @param[in] func The alpha function to use.
428 DALI_IMPORT_API void SetAlphaFunction(AlphaFunction func);
431 * @brief Retrieve the alpha function used when applying constraints
433 * @return The alpha function.
435 DALI_IMPORT_API AlphaFunction GetAlphaFunction() const;
440 * @brief Create a new ItemLayout; Only derived versions are instantiatable.
442 DALI_IMPORT_API ItemLayout();
446 ControlOrientation::Type mOrientation; ///< the orientation of the layout.
447 AlphaFunction mAlphaFunction; ///<Alpha function to be applied when removing/adding constraints
450 } // namespace Toolkit
454 #endif // __DALI_TOOLKIT_ITEM_LAYOUT_H__