efl/src/lib/elementary/elm_toolbar_item.eo

enum Elm.Toolbar_Item_Scrollto_Type
{
   [[Defines where to position the item in the toolbar.]]
   legacy: elm_toolbar_item_scrollto;

   none = 0, [[no scrollto]]
   in = (1 << 0), [[to the nearest viewport]]
   first = (1 << 1), [[to the first of viewport]]
   middle = (1 << 2), [[to the middle of viewport]]
   last = (1 << 3) [[to the last of viewport]]
}

struct Elm.Toolbar_Item_State
{
   [[
     State of a Elm_Toolbar_Item.
     Can be created with elm_toolbar_item_state_add() and removed with elm_toolbar_item_state_del().
   ]]
   label: string; [[Item label]]
   icon_str: string; [[Item icon string]]
   icon: Efl.Canvas.Object; [[Item icon]]
   func: Evas_Smart_Cb ; [[Item callback function]]
   data: const(void_ptr); [[Item data]]
}

class Elm.Toolbar_Item extends Elm.Widget.Item implements Efl.Ui.Focus.Object, Efl.Ui.Legacy
{
      [[Elementary toolbar item class]]
      legacy_prefix: elm_toolbar_item;
      eo_prefix: elm_obj_toolbar_item;
      methods {
           @property prev {
                get {
                   [[Get the item before this one in the widget's list of items.

                     See also @.next.
                   ]]
                }
                values {
                    item: Elm.Widget.Item; [[The item before the object in its parent's
                                              list. If there is no previous item or in case
                                              of error, $null is returned.]]
                }
           }
           @property next {
                get {
                   [[Get the item after this one in the widget's list of items.

                     See also @.prev.
                   ]]
                }
                values {
                   item: Elm.Widget.Item; [[The item after the object in its parent's
                                             list. If there is no next item or in case
                                             of error, $null is returned.]]
                }
           }
           @property selected {
                [[Indicates whether this item is currently selected.]]
                get {
                   [[Get the selected state of this item.]]
                }
                set {
                   [[Set the selected state of $item.

                     This sets the selected state of the given item $it.
                     $true for selected, $false for not selected.

                     If a new item is selected the previously selected will
                     be unselected. Previously selected item can be retrieved
                     with @Elm.Toolbar.selected_item.get.

                     Selected items will be highlighted.
                   ]]
                }
                values {
                   selected: bool; [[The selection state.]]
                }
           }
           @property priority {
                get {
                     [[Get the priority of a toolbar item.]]
                }
                set {
                     [[Set the priority of a toolbar item.

                       This is used only when the toolbar shrink mode is set
                       to #ELM_TOOLBAR_SHRINK_MENU or #ELM_TOOLBAR_SHRINK_HIDE.
                       When space is less than required, items with low priority
                       will be removed from the toolbar and added to a
                       dynamically-created menu, while items with higher
                       priority will remain on the toolbar, with the same
                       order they were added.
                     ]]
                }
                values {
                     priority: int; [[The $item priority. The default is zero
                                      for set and 0 is returned on failure.]]
                }
           }
           @property icon {
                get {
                     [[Get the string used to set the icon of $item.]]
                }
                set {
                     [[Set the icon associated with $item.

                       Toolbar will load icon image from fdo or current theme.
                       This behavior can be set by
                       elm_toolbar_icon_order_lookup_set function.
                       If an absolute path is provided it will load it direct
                       from a file.

                       Note: This function does not accept relative icon path.
                     ]]
                }
                values {
                     icon: string; [[A string with icon name or the
                                           absolute path of an image file.]]
                }
           }
           @property object {
                get {
                     [[Get the real Evas(Edje) object created to implement the
                       view of a given toolbar $item.
                     ]]
                }
                values {
                     obj: Efl.Canvas.Object; [[The base Edje object associated with $it.]]
                }
           }
           @property icon_object {
                get {
                     [[Get the icon object of $item.

                       See also @.icon.set, @.icon_file_set, @.icon_memfile_set.
                     ]]
                }
                values {
                     obj: Efl.Canvas.Object; [[The icon object.]]
                }
           }
           @property separator {
                get {
                     [[Get a value whether item is a separator or not.]]
                }
                set {
                     [[Set or unset item as a separator.

                       Items aren't set as separator by default.

                       If set as separator it will display separator theme, so
                       won't display icons or label.
                     ]]
                }
                values {
                     separator: bool; [[$true if the item is a separator, $false otherwise]]
                }
           }
           @property menu {
                get {
                     [[Get toolbar item's menu.

                       If $item wasn't set as menu item with @.menu_set,
                       this function will set it.
                     ]]
                }
                values {
                     menu: Efl.Canvas.Object; [[Item's menu object or $null on failure.]]
                }
           }
           @property state {
                get {
                     [[Get the current state of $it.]]
                }
                set {
                     [[Set $state as the current state of $it.

                       If $state is $NULL, it won't select any state and the
                       default item's icon and label will be used. It's the
                       behavior as \@ref elm_toolbar_item_state_unset.
                     ]]
                     return: bool; [[$true on success, $false otherwise]]
                }
                values {
                     state: ptr(Elm.Toolbar_Item_State) @nullable; [[Item state]]
                }
           }
           /*      init { FIXME
                   params {
                   Evas_Smart_Cb func;
                   const(void_ptr) data;
                   }
                   }*/
           icon_memfile_set {
                [[Set the icon associated with $item to an image in a binary buffer.

                  Note: The icon image set by this function can be changed by
                  @.icon.set.
                ]]
                params {
                     @in img: const(void_ptr); [[The binary data that will be used as an image.]]
                     @in size: size; [[The size of binary data $img.]]
                     @in format: string; [[Optional format of $img to pass to the image loader.]]
                     @in key: string; [[Optional key of $img to pass to the image loader (eg. if $img is an edje file).]]
                }
                return: bool; [[$true on success, $false otherwise]]
           }
           icon_file_set {
                [[Set the icon associated with $item to an image in a binary buffer.

                  Note: The icon image set by this function can be changed by
                  elm_toolbar_item_icon_set().
                ]]
                params {
                     @in file: string; [[The file that contains the image.]]
                     @in key: string; [[Optional key of $img to pass to the image loader (eg. if $img is an edje file).]]
                }
                return: bool; [[$true on success, $false otherwise]]
           }
           state_add {
                [[Add a new state to $item.

                  Toolbar will load icon image from fdo or current theme.
                  This behavior can be set by elm_toolbar_icon_order_lookup_set
                  function. If an absolute path is provided it will load it
                  direct from a file.

                  States created with this function can be removed with
                  @.state_del.
                ]]
                params {
                     @in icon: string; [[A string with icon name or the absolute path of an image file.]]
                     @in label: string; [[The label of the new state.]]
                     @in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked when this state is selected.]]
                     @in data: const(void_ptr) @optional; [[The data to associate with the state.]]
                }
                return: ptr(Elm.Toolbar_Item_State); [[The toolbar item state, or $null upon failure.]]
           }
           state_del {
                [[Delete a previously added state to $item.]]
                params {
                     @in state: ptr(Elm.Toolbar_Item_State); [[The state to be deleted.]]
                }
                return: bool; [[$true on success or $false on failure.]]
           }
           state_next {
                [[Get the state after selected state in toolbar's $item.

                  If last state is selected, this function will return first
                  state.
                ]]
                return: ptr(Elm.Toolbar_Item_State); [[The state after current state, or $null on failure.]]
           }
           state_prev {
                [[Get the state before selected state in toolbar's $item.

                  If first state is selected, this function will return last
                  state.
                ]]
                return: ptr(Elm.Toolbar_Item_State); [[The state before current state, or $null on failure.]]
           }
           show {
                [[Show a specific item, when the toolbar can be scrolled.

                  @since 1.8
                ]]
                params {
                     @in scrollto: Elm.Toolbar_Item_Scrollto_Type; [[The position the item should appear at.]]
                }
           }
           bring_in {
                [[Show a specific item with scroll animation, when the toolbar
                  can be scrolled.

                  @since 1.8
                ]]
                params {
                     @in scrollto: Elm.Toolbar_Item_Scrollto_Type; [[The position the item should appear at.]]
                }
           }
           menu_set {
                [[Set whether the toolbar item opens a menu.

                  A toolbar item can be set to be a menu, using this function.

                  Once it is set to be a menu, it can be manipulated through the
                  menu-like function @Elm.Toolbar.menu_parent.set and the
                  other elm_menu functions, using the Evas_Object $menu returned
                  by @.menu.get.

                  So, items to be displayed in this item's menu should be added
                  with \@ref elm_menu_item_add.
                ]]
                /* FIXME-doc
                 The following code exemplifies the most basic usage:
                 @code
                 tb = elm_toolbar_add(win)
                 item = elm_toolbar_item_append(tb, "refresh", "Menu", NULL, NULL);
                 elm_toolbar_item_menu_set(item, true);
                 elm_toolbar_menu_parent_set(tb, win);
                 menu = elm_toolbar_item_menu_get(item);
                 elm_menu_item_add(menu, NULL, "edit-cut", "Cut", NULL, NULL);
                 menu_item = elm_menu_item_add(menu, NULL, "edit-copy", "Copy", NULL,
                 NULL);
                 @endcode
                */
                params {
                     @in menu: bool; [[If $true, $item will opens a menu when selected.]]
                }
           }
      }
      implements {
           Efl.Object.constructor;
           Efl.Object.invalidate;
           Elm.Widget.Item.disable;
           Elm.Widget.Item.disabled { set; }
           Elm.Widget.Item.item_focus { get; set; }
           Elm.Widget.Item.signal_emit;
           Elm.Widget.Item.part_text { get; set; }
           Elm.Widget.Item.part_content { get; set; }
           Elm.Widget.Item.part_content_unset;
           Efl.Ui.Focus.Object.focus_geometry { get; }
           Efl.Ui.Focus.Object.focus { set; }
           Efl.Ui.Focus.Object.focus_parent { get; }
           Efl.Access.Object.i18n_name { get; }
           Efl.Access.Object.state_set { get; }
      }
}