path: root/src/lib/elementary/elm_widget_item.eo

import elm_general;
import efl_ui;

type Elm_Tooltip_Item_Content_Cb: __undefined_type; [[Elementary tooltip item content callback type]]
type Elm_Object_Item_Signal_Cb: __undefined_type; [[Elementary object item signal callback type]]

class Elm.Widget.Item extends Efl.Object implements Efl.Access.Object,
                      Efl.Access.Component, Efl.Access.Action
{
      [[Elementary widget item class]]
      eo_prefix: elm_wdg_item;
      legacy_prefix: elm_object_item;
      methods {
           @property tooltip_window_mode {
               [[Control size restriction state of an object's tooltip

                 This function returns whether a tooltip is allowed to expand beyond
                 its parent window's canvas.
                 It will instead be limited only by the size of the display.]]
                get {
                }
                set {
                     return: bool; [[$false on failure, $true on success]]
                }
                values {
                     disable: bool; [[If $true, size restrictions are disabled]]
                }
           }
           @property tooltip_style {
                [[Control a different style for this item tooltip.

                  Note: before you set a style you should define a tooltip with
                  @.tooltip_content_cb_set or
                  @.tooltip_text_set

                  See: elm_object_tooltip_style_set() for more details.]]
                get {
                }
                set {
                }
                values {
                     style: string; [[The theme style used/to use (default, transparent, ...)]]
                }
           }
           @property cursor {
                [[Control the type of mouse pointer/cursor decoration to be shown,
                  when the mouse pointer is over the given item

                  This function works analogously as elm_object_cursor_set(), but
                  here the cursor's changing area is restricted to the item's
                  area, and not the whole widget's. Note that that item cursors
                  have precedence over widget cursors, so that a mouse over an
                  item with custom cursor set will always show that cursor.

                  If this function is called twice for an object, a previously set
                  cursor will be unset on the second call.]]
                get {
                }
                set {
                }
                values {
                     cursor: string; [[The cursor type's name]]
                }
           }
           @property cursor_style {
                [[Control a different $style for a given custom cursor set for an item.

                  This function only makes sense when one is using custom mouse
                  cursor decorations defined in a theme file, which can have,
                  given a cursor name/type, alternate styles on it. It
                  works analogously as elm_object_cursor_style_set(), but here
                  applies only to item objects.

                  Warning: Before you set a cursor style you should have defined a
                  custom cursor previously on the item, with @.cursor.set]]
                get {
                }
                set {
                }
                values {
                     style: string; [[The theme style to use/in use (e.g. $"default", $"transparent", etc)]]
                }
           }
           @property cursor_engine_only {
                [[Control if the (custom)cursor for a given item should be
                  searched in its theme, also, or should only rely on the
                  rendering engine.

                  Note: This call is of use only if you've set a custom cursor
                  for items, with @.cursor.set.

                  Note: By default, cursors will only be looked for between those
                  provided by the rendering engine.]]
                get {
                }
                set {
                }
                values {
                     engine_only: bool; [[Use $true to have cursors looked for only on those provided by the rendering engine, $false to have them searched on the widget's theme, as well.]]
                }
           }
           @property part_content {
                [[Control a content of an object item

                  This sets a new object to an item as a content object. If any object was
                  already set as a content object in the same part, previous object will be
                  deleted automatically.]]
                get {
                }
                set {
                }
                keys {
                     part: string @nullable; [[The content part name  (NULL for the default content)]]
                }
                values {
                     content: Efl.Canvas.Object; [[The content of the object item]]
                }
           }
           @property part_text {
                [[Control a label of an object item

                  Note: Elementary object items may have many labels]]
                get {
                }
                set {
                }
                keys {
                     part: string @nullable; [[The text part name (NULL for the default label)]]
                }
                values {
                     label: string; [[Text of the label]]
                }
           }
           @property part_text_custom @protected {
                get {
                     [[Get additional text part content]]
                     legacy: null;
                }
                set {
                     [[Save additional text part content]]
                     legacy: null;
                }
                keys {
                     part: string; [[Part name]]
                }
                values {
                     label: string; [[Label name]]
                }
           }
           @property item_focus {
                [[Control the object item focused

                  @since 1.10]]
                get {
                   legacy: elm_object_item_focus_get;
                }
                set {
                   legacy: elm_object_item_focus_set;
                }
                values {
                     focused: bool; [[The focused state]]
                }
           }
           @property style {
                [[Control the style of an object item

                  @since 1.9]]
                get {
                }
                set {
                }
                values {
                     style: string; [[The style of object item]]
                }
           }
           @property disabled {
                [[Control the disabled state of a widget item.

                  Elementary object item can be disabled, in which state they won't
                  receive input and, in general, will be themed differently from
                  their normal state, usually greyed out. Useful for contexts
                  where you don't want your users to interact with some of the
                  parts of you interface.

                  This sets the state for the widget item, either disabling it or
                  enabling it back.]]
                get {
                }
                set {
                }
                values {
                     disable: bool; [[$true, if the widget item is disabled, $false if it's enabled (or on errors)]]
                }
           }
           access_order_get {
                  [[Get highlight order

                    @since 1.8]]
                return: const(list<Efl.Canvas.Object>); [[List of evas canvas objects]]
           }
           access_order_set {
                [[Set highlight order

                  @since 1.8]]
                params {
                     @in objs: list<Efl.Canvas.Object> @owned; [[Order of objects to pass highlight]]
                }
           }
           widget_get @const {
                [[Get the widget object's handle which contains a given item

                  Note: This returns the widget object itself that an item belongs to.
                  Note: Every elm_object_item supports this API]]
                  return: Efl.Canvas.Object; [[The widget object]]
           }
           pre_notify_del @protected {
                [[notify deletion of widget item]]
                legacy: null;
           }
           tooltip_text_set {
                [[Set the text to be shown in a given object item's tooltips.

                  Setup the text as tooltip to object. The item can have only one tooltip,
                  so any previous tooltip data - set with this function or
                  @.tooltip_content_cb_set - is removed.

                  See: elm_object_tooltip_text_set() for more details.]]
                params {
                     text: string; [[The text to set in the content.]]
                }
           }
           tooltip_translatable_text_set @protected {
                [[Set widget item tooltip as a text string]]
                legacy: null;
                params {
                     text: string; [[Tooltip text]]
                }
           }
           tooltip_unset {
                [[Unset tooltip from item.

                  Remove tooltip from item. The callback provided as del_cb to
                  @.tooltip_content_cb_set will be called to notify
                  it is not used anymore.

                  See: elm_object_tooltip_unset() for more details.
                  See: @.tooltip_content_cb_set]]
           }
           cursor_unset {
                [[Unset any custom mouse pointer/cursor decoration set to be
                  shown, when the mouse pointer is over the given
                  item, thus making it show the default cursor again.

                  Use this call to undo any custom settings on this item's cursor
                  decoration, bringing it back to defaults (no custom style set).

                  See: elm_object_cursor_unset()
                  See: @.cursor.set]]
           }
           part_content_unset {
                [[Unset a content of an object item

                  Note: Elementary object items may have many contents]]
                params {
                     part: string; [[The content part name to unset (NULL for the default content)]]
                }
                return: Efl.Canvas.Object; [[Content object]]
           }
           part_text_custom_update @protected {
                [[Update additional text part content]]
                legacy: null;
           }
           signal_callback_add {
                [[Add a callback for a signal emitted by object item edje.

                  This function connects a callback function to a signal emitted by the
                  edje object of the object item.
                  Globs can occur in either the emission or source name.

                  @since 1.8]]
                params {
                     emission: string; [[The signal's name.]]
                     source: string; [[The signal's source.]]
                     func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
                     data: void_ptr; [[A pointer to data to pass to the callback function.]]
                }
           }
           signal_callback_del {
                [[Remove a signal-triggered callback from a object item edje object.

                  This function removes the last callback, previously attached to
                  a signal emitted by an underlying Edje object of $it, whose
                  parameters $emission, $source and $func match exactly with
                  those passed to a previous call to
                  @.signal_callback_add. The data pointer that was passed
                  to this call will be returned.

                  See: @.signal_callback_add

                  @since 1.8]]
                params {
                     emission: string; [[The signal's name.]]
                     source: string; [[The signal's source.]]
                     func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
                }
                return: void_ptr; [[The data pointer of the signal callback or $NULL, on errors.]]
           }
           signal_emit {
                [[Send a signal to the edje object of the widget item.

                  This function sends a signal to the edje object of the obj item. An
                  edje program can respond to a signal by specifying matching
                  'signal' and 'source' fields.
                  Don't use this unless you want to also handle resetting of part states to default on
                  every unrealize in case of genlist/gengrid.]]
                params {
                     emission: string; [[The signal's name.]]
                     source: string; [[The signal's source.]]
                }
           }
           access_info_set {
                [[Set the text to read out when in accessibility mode]]
                params {
                     txt: string; [[The text that describes the widget to people with poor or no vision]]
                }
           }
           access_object_get @const {
                [[Get an accessible object of the object item.

                  @since 1.8]]
                return: Efl.Canvas.Object; [[Accessible object of the object item or NULL for any error]]
           }
           domain_translatable_part_text_set {
                [[Set the text for an object item's part, marking it as translatable.

                  The string to set as $text must be the original one. Do not pass the
                  return of $gettext() here. Elementary will translate the string
                  internally and set it on the object item using
                  @.part_text.set, also storing the original string so that it
                  can be automatically translated when the language is changed with
                  elm_language_set(). The $domain will be stored along to find the
                  translation in the correct catalog. It can be NULL, in which case it will use
                  whatever domain was set by the application with $textdomain(). This is
                  useful in case you are building a library on top of Elementary that will have
                  its own translatable strings, that should not be mixed with those of programs
                  using the library.

                  @since 1.8]]
                params {
                     part: string; [[The name of the part to set]]
                     domain: string; [[The translation domain to use]]
                     label: string; [[The original, non-translated text to set]]
                }
           }
           translatable_part_text_get @const {
                [[Get the original string set as translatable for an object item.

                  When setting translated strings, the function @.part_text.get
                  will return the translation returned by $gettext(). To get the original
                  string use this function.

                  @since 1.8]]
                params {
                     part: string; [[The name of the part that was set]]
                }
                return: string; [[The original, untranslated string]]
           }
           translate @protected {
                [[Query translate]]
                legacy: null;
           }
           domain_part_text_translatable_set {
                [[Mark the part text to be translatable or not.

                  Once you mark the part text to be translatable, the text will be translated
                  internally regardless of @.part_text.set and
                  @.domain_translatable_part_text_set. In other case, if you
                  set the Elementary policy that all text will be translatable in default, you
                  can set the part text to not be translated by calling this API.

                  See: @.domain_translatable_part_text_set
                  See: @.part_text.set
                  See: elm_policy()

                  @since 1.8]]
                params {
                     part: string; [[The part name of the translatable text]]
                     domain: string; [[The translation domain to use]]
                     translatable: bool; [[$true, the part text will be translated internally. $false, otherwise.]]
                }
           }
           track {
                [[This returns track object of the item.

                  Note: This gets a rectangle object that represents the object item's internal
                  object. If you want to check the geometry, visibility of the item, you
                  can call the evas apis such as evas_object_geometry_get(),
                  evas_object_visible_get() to the track object. Note that all of the
                  widget items may/may not have the internal object so this api may
                  return $NULL if the widget item doesn't have it. Additionally, the
                  widget item is managed/controlled by the widget, the widget item could
                  be changed(moved, resized even deleted) anytime by it's own widget's
                  decision. So please dont' change the track object as well as don't
                  keep the track object in your side as possible but get the track object
                  at the moment you need to refer. Otherwise, you need to add some
                  callbacks to the track object to track it's attributes changes.

                  Warning: After use the track object, please call the
                  @.untrack() paired to elm_object_item_track
                  definitely to free the track object properly. Don't delete the
                  track object.

                  See: @.untrack
                  See: @.track_get

                  @since 1.8]]
                return: Efl.Canvas.Object; [[The track object]]
           }
           untrack {
                [[This retrieve the track object of the item.

                  Note: This retrieves the track object that was returned from
                  @.track.

                  See: @.track
                  See: @.track_get

                  @since 1.8]]
           }
           track_get @const {
                [[Get the track object reference count.

                  Note: This gets the reference count for the track object. Whenever you call
                  the @.track, the reference count will be increased by
                  one. Likely the reference count will be decreased again when you call
                  the @.untrack. Unless the reference count reaches to
                  zero, the track object won't be deleted. So please be sure to call
                  @.untrack() paired to the elm_object_item_track call
                  count.

                  See: @.track
                  See: @.track_get

                  @since 1.8]]
                return: int; [[Track object reference count]]
           }
           track_cancel @protected {
                [[Query track_cancel]]
                legacy: null;
           }
           del_cb_set {
                [[Set the function to be called when an item from the widget is
                  freed.

                  Note: Every elm_object_item supports this API]]
                params {
                     del_cb: Evas_Smart_Cb @nullable; [[The function called]]
                }
           }
           tooltip_content_cb_set {
                [[Set the content to be shown in the tooltip item.

                  Setup the tooltip to item. The item can have only one tooltip,
                  so any previous tooltip data is removed. $func(with $data) will
                  be called every time that need show the tooltip and it should
                  return a valid Evas_Object. This object is then managed fully by
                  tooltip system and is deleted when the tooltip is gone.

                  See: elm_object_tooltip_content_cb_set() for more details.]]
                params {
                     func: Elm_Tooltip_Item_Content_Cb @nullable; [[The function used to create the tooltip contents.]]
                     data: const(void_ptr) @optional; [[What to provide to $func as callback data/context.]]
                     del_cb: Evas_Smart_Cb @optional; [[Called when data is not needed anymore, either when another callback replaces $func, the tooltip is unset with @.tooltip_unset or the owner $item dies. This callback receives as the first parameter the given $data, and $event_info is the item.]]

                }
           }
           access_register {
                [[Register object item as an accessible object.

                  @since 1.8]]
                return: Efl.Canvas.Object; [[Accessible object of the object item or NULL for any error]]
           }
           access_unregister {
                [[Unregister accessible object of the object item.

                  @since 1.8]]
           }
           access_order_unset {
                [[Unset highlight order

                  @since 1.8]]
           }
           disable @protected {
              [[Disable widget item]]
                legacy: null;
           }
           del_pre @protected {
              [[Delete pre widget item]]
                legacy: null;
           }
           focus_next_object_get @const {
                [[Get the next object with specific focus direction.

                  @since 1.16]]
                params {
                     dir: Efl.Ui.Focus.Direction; [[Focus direction]]
                }
                return: Efl.Canvas.Object; [[Focus next object]]
           }
           focus_next_object_set {
                [[Set the next object with specific focus direction.

                  @since 1.16]]
                params {
                     next: Efl.Canvas.Object @nullable; [[Focus next object]]
                     dir: Efl.Ui.Focus.Direction; [[Focus direction]]
                }
           }
           focus_next_item_get @const {
                [[Get the next object item with specific focus direction.

                  @since 1.16]]
                params {
                     dir: Efl.Ui.Focus.Direction; [[Focus direction]]
                }
                return: Elm.Widget.Item; [[Focus next object item]]
           }
           focus_next_item_set {
                [[Set the next object item with specific focus direction.

                  @since 1.16]]
                params {
                     next_item: Elm.Widget.Item @nullable; [[Focus next object item]]
                     dir: Efl.Ui.Focus.Direction; [[Focus direction]]
                }
           }
           @property access_actions @protected @beta {
              [[Elementary accessibility actions]]
              get {
              }
              values {
                 @cref actions: ptr(const(Efl.Access.Action_Data));
                    [[NULL-terminated array of Efl.Access.Action_Data.]]
              }
      }
      }
      implements {
           Efl.Object.constructor;
           Efl.Object.destructor;
           Efl.Object.invalidate;
           Efl.Access.Object.state_set { get; }
           Efl.Access.Object.attributes { get; }
           Efl.Access.Component.extents { get; set; }
           Efl.Access.Component.focus_grab;
           Efl.Access.Component.screen_position { get; set; }
           Efl.Access.Component.contains;
           Efl.Access.Component.accessible_at_point_get;
           Efl.Access.Component.z_order { get; }
           Efl.Access.Action.action_do;
           Efl.Access.Action.action_keybinding_get;
           Efl.Access.Action.action_name { get; }
           Efl.Access.Action.action_localized_name { get; }
           Efl.Access.Action.action_description { get; set; }
           Efl.Access.Action.actions { get; }
      }
}