#include <hbabstractviewitem_p.h>

#include <hbdataform.h>

#include <QSortFilterProxyModel>

    \brief The HbAbstractItemView class defines a set of common properties for the item view classes that derive from it.

    The item view classes derived from %HbAbstractItemView are widgets used to display items of related data in a scrollable area. For example,

    derived views are provided to display a sequential list, a tree, a grid and a form. The items of data are typically icons and text. 

    This class and its derived classes use Qt's model/view framework, which requires that the data to be displayed is stored first in the model. The only exception to this is the HbListWidget class, which does not require an existing model. The model can be any QAbstractItemModel-based model. This framework provides a standard interface for communicating with models through the signals and slots mechanism, which ensures the views are  updated when the model is changed. The QAbstractItemModel class describes the concepts of the model such as the \e index of the model, model \e items and \e roles.

    The individual view items are objects derived from HbAbstractViewItem. %HbAbstractItemView stores a list of HbAbstractViewItems

    and manages these view items for you. By changing this list the view items can be customized. The

     %HbAbstractItemView class explains how this can be done.

    %HbAbstractItemView is an abstract class and cannot itself be instantiated. Therefore please refer to the derived classes (HbListView, HbGridView, HbTreeView, HbDataForm) for examples of use.

    %HbAbstractItemView provides properties that you can use to customize the following aspects of a view:  

    - <b>Item sizes</b>. You can set the items to all display at the same size using setUniformItemSizes(), which  improves performance for some operations such as scrolling. 

    - <b>Item recycling</b>. You can enable item recycling via setItemRecycling() to save memory. When item recycling is enabled, the view does not create a view item for every model item immediately after the view is launched. Instead, it creates view items for the visible area plus a few adjacent extra items. When the view is scrolled the existing view items are updated with new data from the model. By default item recycling is off.

    - <b>Pixmap cache</b>. You can enable the pixmap cache via setItemPixmapCacheEnabled() to significantly improve scrolling speed. It 

    is recommended that the cache is enabled except in cases where the cache would potentially cause problems. By default the pixmap cache is off.

    - <b>View scrolling</b>. You can scroll the view to ensure a particular item is shown by using scrollTo(). The function takes an optional hint parameter to define which part of the scroll area should contain the item, such as the middle or the top. Typically %scrollTo() is used after the creation of a view or to set a specific position for a newly added item.

    - <b>%Selection Mode</b>. You can change the selection mode to either single or multiple using setSelectionMode(). You can also modify the

    existing selection using clearSelection() and selectAll().

    - <b>%Selection Model</b>. You can change the selection model using setSelectionModel().

    - <b>Icon load policy</b>. You can change the icon load policy so that icons are loaded synchronously or asynchronously using setIconLoadPolicy(). By default icons are loaded asynchronously to improve performance, but this can result in empty areas being displayed while the icons are still being loaded.

    \section Subclassing

    %HbAbstractItemView can be subclassed for customization purposes.

    \sa  HbAbstractViewItem

    the view item that is representing \a index.

    \sa released() activated()

    the view item that is representing \a index.

    \sa pressed(), activated(), HbAbstractViewItem::released(const QPointF &position)

    An item is activated for example by clicking the item with a mouse

    or by tapping the item.

    \sa pressed(), released()

    This signal is emitted when a long press event is received by a view item.

    \param item The view item that received the long press event.

    \param coords The scene position where the long press event happened.

    Defines the available selection types.

    When the user selects an item, all other items become deselected. The user cannot

    deselect the selected item.

    When the user selects an item, the selection state of that item

    is toggled and the other items are left unchanged. 

    Defines the positions on the view that an item can be scrolled to.

    \sa scrollTo()

    The item will be fully visible in the view. 

    The item will be fully visible as the topmost item.

    The item will be fully visible as the bottommost item.

    The item will be centered in the view.

    Defines the types of animations in %HbAbstractItemView. The values are designed to be used as flags.

    By default all animations are enabled.

    The ItemAnimations type is a typedef for QFlags<ItemAnimation>. It stores an OR combination of the ItemAnimation values.

    No animations are applied. 

    The animation displayed during item appearance. This animation can be disabled if desired. Disable this animation in cases where you expect many model items to appear,

    such as during the insertion of a new data source. Note that the item appearance animations are not used directly after a call to setModel().

    The animation displayed during item removal. This animation can be disabled if desired. Disable this animation in cases where you expect many model items to disappear, such as during the filtering or removal of a data source.

    The animations displayed during item press and release events. This animation can be disabled if desired.

    The animation displayed when a setting item is expanded.

    The animation displayed when a setting item is collapsed.

    A combination of all the flags. Every animation is applied. 

*/

/*!

    \enum HbAbstractItemView::IconLoadPolicy

    Defines the icon load policies that are used to control how icon data is loaded into items.

    \var HbAbstractItemView::LoadSynchronously

    The icon data for items is always loaded synchronously. In this mode the items will block all other processing while they load their icons.  This can lead to longer item creation time and data update times which may result in poor performance especially while scrolling.

    The benefit is that the icon content is guaranteed to be painted immediately so this avoids the possibility of empty areas that might appear if the data is loaded asynchronously.

*/

/*!

    \var HbAbstractItemView::LoadAsynchronouslyWhenScrolling

    The icon data is loaded asynchronously during scrolling but otherwise the data is loaded synchronously. 

*/

/*!

    \var HbAbstractItemView::LoadAsynchronouslyAlways

    The icon data is always loaded asynchronously. In this mode the process of loading the icon data will not block other processing 

    and so will not cause delays in item creation or data update times. This results in better scrolling 

    performance since the item recycling delay is shared between different frames. 

    The disadvantage for this mode is that icon content is not guaranteed to be painted immediately and this may cause empty areas 

    to be painted while asynchronous data is being loaded.

    This is the default mode.

    Constructs a new %HbAbstractItemView with the given (private data) \a dd, \a container, \a model \a iterator and \a parent.

    Constructs a new %HbAbstractItemView with \a container, \a modelIterator and \a parent.

    Destructor.

    Returns the model that the view is currently presenting.

    \sa setModel()

    Sets the model to \a model and replaces the current item prototype with \a prototype.

    If no prototype has been passed, the default prototype for the item view is used.

    \note This function may cause existing view items to be recreated. The recreated view items are created asynchronously.

    \sa model(), setItemPrototype

    Returns the list of item prototypes. How to use item prototypes is described in HbAbstractViewItem.

    \sa setItemPrototype(), setItemPrototypes()

    Replaces the current item prototypes with \a prototype and takes ownership of the prototype.

    \note This function may cause existing view items to be recreated. The recreated view items are created asynchronously.

    \note Supplied item views such as HbListView have default prototypes which are set when the item view class is created.

    \sa itemPrototypes(), setItemPrototypes()

/*! 

    Replaces the current item prototypes with the list of \a prototypes and takes ownership of the \a prototypes.

    This allows multiple abstract view items within %HbAbstractItemView.

    When list view items are being created, the choice of which prototype to use for each item is 

    based on the order of the prototypes and each prototype's response to the view calling HbAbstractViewItem::canSetModelIndex().

    The prototype list is read from the end to the beginning. 

    The recommended list order is to place specialized prototypes at the end of the list and a

    default prototype at the list head. The specialized prototypes would create

    only certain types of list view items and so would implement HbAbstractViewItem::canSetModelIndex().

     The default prototype would always return \c true for HbAbstractViewItem::canSetModelIndex() and would be capable of creating

     any type of list view item. The specialized prototypes would be expected to create more complex items from extra data in the

     model that the default prototype would otherwise ignore.

    Supplied item views such as HbListView have default prototypes which are set when the item view class is created.

    \note Setting more than one prototype will disable the item recycling feature.

    \note This function may cause existing view items to be recreated. The recreated view items are created asynchronously.

    \sa setItemPrototype(), itemPrototypes()

    \sa setSelectionModel

    \note If setModel() is called after this function, the selection model will be

    replaced by the default selection model of the view.

    \sa selectionModel

    Sets the current selection mode to \a newMode.

    If \a newMode is different from the current selection mode for the view,

    this function updates all view items and clears all existing selections.

    \sa selectionMode()

    Deselects all selected items. The current index is not changed.

 */

    Returns the current selection mode used by the view.

    \sa setSelectionMode

    Returns the index of the current item.