import elm_general;

enum Elm.Gengrid.Item.Scrollto_Type
{
   [[Defines where to position the item in the genlist.]]
   legacy: elm_gengrid_item_scrollto;
   none = 0,   [[No scrollto.]]
   in = (1 << 0),   [[To the nearest viewport.]]
   top = (1 << 1),   [[To the top of viewport.]]
   middle = (1 << 2),   [[To the middle of viewport.]]
   // @tizen_feature
   bottom = (1 << 3)   [[To the bottom of viewport.]]
   //
}

enum Elm.Gengrid.Item.Field_Type
{
   [[Defines the type of the item part Used while updating item's parts.
     It can be used at updating multi fields.]]
   legacy: elm_gengrid_item_field;
   all = 0,
   text = (1 << 0),
   content = (1 << 1),
   state = (1 << 2)
}


class Elm.Gengrid_Item(Elm.Widget_Item)
{
      eo_prefix: elm_obj_gengrid_item;
      data: Elm_Gen_Item;
      methods {
           @property prev {
                get {
                     [[\@MOBILE_ONLY

                       Get the previous item in a gengrid widget's internal list of items, given a handle to one of those items.

                       This returns the item placed before the $item, on the container
                       gengrid.

                       \@if MOBILE \@since_tizen 2.3
                       \@endif
                     ]]
                }
                values {
                     item: Elm.Widget_Item *; [[The item before $item, or $NULL if there's none (and on errors)]]
                }
           }
           @property next {
                get {
                     [[\@MOBILE_ONLY

                       Get the next item in a gengrid widget's internal list of items,
                       given a handle to one of those items.

                       This returns the item placed after the $item, on the container
                       gengrid.

                       \@if MOBILE \@since_tizen 2.3
                       \@endif
                     ]]
                }
                values {
                     item: Elm.Widget_Item *; [[The item after $item, or $NULL if there's none (and on errors)]]
                }
           }
           @property selected {
                [[Control whether a given gengrid item is selected or not

                  This API returns true for all the items selected in multi-select mode as well.

                  This sets the selected state of an item. If multi-selection is
                  not enabled on the containing gengrid and $selected is
                  true, any other previously selected items will get
                  unselected in favor of this new one.]]
                get {
                   [[\@MOBILE_ONLY

                     \@if MOBILE \@since_tizen 2.3
                     \@endif
                   ]]
                }
                set {
                   [[\@MOBILE_ONLY

                     \@if MOBILE \@since_tizen 2.3
                     \@endif
                   ]]
                }
                values {
                     selected: bool; [[the selected state ($true selected, $false not selected)]]
                }
           }
           @property item_class {
                get {
                     [[\@MOBILE_ONLY

                       Get the Gengrid Item class for the given Gengrid Item.

                       This returns the Gengrid_Item_Class for the given item. It can be used to examine
                       the function pointers and item_style.

                       \@if MOBILE \@since_tizen 2.3
                       \@endif
                     ]]
                }
                values {
                     itc: const (Elm_Gengrid_Item_Class) *; [[Gengrid Item class for the given item]]
                }
           }
           @property index {
                get {
                     [[\@MOBILE_ONLY

                       Get the index of the item. It is only valid once displayed.

                       \@if MOBILE \@since_tizen 2.3
                       \@endif
                     ]]
                }
                values {
                     index: int(-1); [[the position inside the list of item.]]
                }
           }
           @property pos {
                get {
                     [[\@MOBILE_ONLY

                       Get a given gengrid item's position, relative to the whole gengrid's grid area.

                       This returns the "logical" position of the item within the
                       gengrid. For example, $(0, 1) would stand for first row,
                       second column.

                       \@if MOBILE \@since_tizen 2.3
                       \@endif
                     ]]
                }
                values {
                     x: uint; [[Pointer to variable to store the item's <b>row number</b>.]]
                     y: uint; [[Pointer to variable to store the item's <b>column number</b>.]]
                }
           }
           @property select_mode {
                [[Control the gengrid item's select mode.

                  (If getting mode fails, it returns ELM_OBJECT_SELECT_MODE_MAX)

                  elm_gengrid_select_mode_set() changes item's select mode.
                  - ELM_OBJECT_SELECT_MODE_DEFAULT : The item will only call their selection func and
                       callback when first becoming selected. Any further clicks will
                       do nothing, unless you set always select mode.
                  - ELM_OBJECT_SELECT_MODE_ALWAYS : This means that, even if selected,
                       every click will make the selected callbacks be called.
                  - ELM_OBJECT_SELECT_MODE_NONE : This will turn off the ability to select the item
                       entirely and they will neither appear selected nor call selected
                       callback functions.
                  - ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY : This will apply no-finger-size rule
                       with ELM_OBJECT_SELECT_MODE_NONE. No-finger-size rule makes an item can be
                       smaller than lower limit. Clickable objects should be bigger than
                       human touch point device (your finger) for some touch or
                       small screen devices. So it is enabled, the item can be shrink than
                       predefined finger-size value. And the item will be updated.]]
                get {
                   [[\@MOBILE_ONLY

                     \@if MOBILE \@since_tizen 2.3
                     \@endif
                   ]]
                }
                set {
                   [[\@MOBILE_ONLY

                     \@if MOBILE \@since_tizen 2.3
                     \@endif
                   ]]
                }
                values {
                     Mode: Elm.Object.Select_Mode(Elm.Object.Select_Mode.max); [[The selected mode]]
                }
           }
           /*      init { FIXME
                   params {
                   Evas_Smart_Cb func;
                   const(void)* data;
                   }
                   }*/
           show {
                [[\@MOBILE_ONLY

                  Show the portion of a gengrid's internal grid containing a given
                  item, immediately.

                  This causes gengrid to redraw its viewport's contents to the
                  region containing the given $item item, if it is not fully
                  visible.

                  \@if MOBILE \@since_tizen 2.3
                  \@endif
                ]]
                params {
                     @in type: Elm_Gengrid_Item_Scrollto_Type; [[Where to position the item in the viewport.]]
                }
           }
           bring_in {
                [[\@MOBILE_ONLY

                  Animatedly bring in, to the visible area of a gengrid, a given item on it.

                  This causes gengrid to jump to the given $item and show
                  it (by scrolling), if it is not fully visible. This will use
                  animation to do so and take a period of time to complete.

                  \@if MOBILE \@since_tizen 2.3
                  \@endif
                ]]
                params {
                     @in type: Elm_Gengrid_Item_Scrollto_Type; [[Where to position the item in the viewport.]]
                }
           }
           update {
                [[\@MOBILE_ONLY

                  Update the contents of a given gengrid item

                  This updates an item by calling all the item class functions
                  again to get the contents, texts and states. Use this when the
                  original item data has changed and you want the changes to be
                  reflected.

                  \@if MOBILE \@since_tizen 2.3
                  \@endif
                ]]
           }
           fields_update {
                [[\@MOBILE_ONLY

                  Update the part of an item

                  This updates an item's part by calling item's fetching functions again
                  to get the contents, texts and states. Use this when the original
                  item data has changed and the changes are desired to be reflected.
                  Second parts argument is used for globbing to match '*', '?', and '.'
                  It can be used at updating multi fields.

                  Use elm_gengrid_realized_items_update() to update an item's all
                  property.

                  \@if MOBILE \@since_tizen 2.4
                  \@endif

                  @since 1.15
                ]]
                params {
                     @in parts: const (char) *; [[The name of item's part]]
                     @in itf: Elm.Gengrid.Item.Field_Type; [[The type of item's part type]]
                }
           }
           item_class_update {
                [[\@MOBILE_ONLY

                  Update the item class of a gengrid item.

                  This sets another class of the item, changing the way that it is
                  displayed. After changing the item class, elm_gengrid_item_update() is
                  called on the item $it.

                  \@if MOBILE \@since_tizen 2.3
                  \@endif
                ]]
                params {
                     @in itc: const (Elm_Gengrid_Item_Class) *; [[The gengrid item class describing the function pointers and the item style.]]
                }
           }
           all_contents_unset{

                 [[Unset all contents fetched by the item class

                 This instructs gengrid to release references to contents in the item,
                 meaning that they will no longer be managed by gengrid and are
                 floating "orphans" that can be re-used elsewhere if the user wants
                 to.

                 \@if MOBILE \@since_tizen 2.4
                 \@elseif WEARABLE \@since_tizen 3.0
                 \@endif
               ]]
                params {
                     @out l: own(list<own(Evas.Object *)> *); [[The contents list to return.]]
                }
           }
           @property custom_size {
                get @internal {
                     [[Get the dimensions of a gengrid item.

                       Gives the dimensions set with elm_gengrid_item_custom_size_set(). If the item
                       has not been modified values set with elm_gengrid_item_size_set() are obtained.

                       @since 1.17]]
                }
                set @internal {
                     [[Resize dimensions of a gengrid item.

                       In case of a horizontal grid, only the widths only be resized and
                       in case of vertical only the heights can be resized. Item size
                       should be set by elm_gengrid_item_size_set() beforehand.

                       The values set by elm_gengrid_item_size_set() will be used for the
                       dimension that remains fixed.

                       @since 1.17]]
                }
                values {
                     w: Evas_Coord; [[The item's width.]]
                     h: Evas_Coord; [[The item's height.]]
                }
           }
      }
      implements {
           Eo.Base.constructor;
           Elm.Widget_Item.del_pre;
           Elm.Widget_Item.disable;
           Elm.Widget_Item.signal_emit;
           Elm.Widget_Item.focus.set;
           Elm.Widget_Item.focus.get;
           Elm.Widget_Item.part_text.get;
           Elm.Widget_Item.part_content.get;
           Elm.Widget_Item.tooltip_text_set;
           Elm.Widget_Item.tooltip_style.get;
           Elm.Widget_Item.tooltip_style.set;
           Elm.Widget_Item.tooltip_window_mode.get;
           Elm.Widget_Item.tooltip_window_mode.set;
           Elm.Widget_Item.tooltip_content_cb_set;
           Elm.Widget_Item.tooltip_unset;
           Elm.Widget_Item.cursor.set;
           Elm.Widget_Item.cursor_unset;
           Elm_Interface_Atspi_Accessible.name.get;
           Elm_Interface_Atspi_Accessible.state_set.get;
           Elm_Interface_Atspi_Accessible.children.get;
           Elm_Interface_Atspi_Component.highlight_grab;
           Elm_Interface_Atspi_Component.highlight_clear;
      }
}
