class Elm.Prefs (Elm.Widget, Efl.File)
{
   eo_prefix: elm_obj_prefs;
   methods {
      @property data {
         [[Set user data for a given prefs widget

           Once a prefs widget is created, after elm_prefs_file_set() is
           issued on it, all of its UI elements will get default values, when
           declared on that file. To fetch an user's own, personal set of
           those values, one gets to pair a prefs data handle to the
           prefs widget. This is what this call is intended for.

           Prefs data values from $prefs_data with keys matching the ones
           present on the file passed on elm_prefs_file_set() to $obj will
           have their values applied to the respective UI elements of the
           widget.

           When $obj dies, the values of the elements declared on its
           .epb file (the one set on elm_prefs_file_set()) marked as permanent
           will be written back to prefs_data, if it is writable.
           One is also able to make this writing event to take place
           automatically after each UI element modification by using
           elm_prefs_autosave_set().

           Note: $obj will keep a reference of its own for $prefs_data,
           but you should still unreference it by yourself, after the widget
           is gone.

           @since 1.8]]
         set @internal {
            return: bool; [[$true, on success, $false otherwise]]
         }
         get @internal {
         }
         values {
            data: Elm_Prefs_Data * @nullable; [[A valid prefs_data handle]]
         }
      }
      @property autosave {
         [[Control whether a given prefs widget should save its values back (on
           the user data file, if set) automatically on every UI element
           changes.

           If $autosave is $true, every call to
           elm_prefs_item_value_set(), every
           Elm_Prefs_Data_Event_Type.ELM_PREFS_DATA_EVENT_ITEM_CHANGED event
           coming for its prefs data and every UI element direct value
           changing will implicitly make the prefs values to be flushed back
           to it prefs data. If a prefs data handle with no writing
           permissions or no prefs data is set on $prefs, naturally nothing
           will happen.

           @since 1.8]]
         set @internal {
         }
         get @internal {
         }
         values {
            autosave: bool; [[$true to save automatically, $false otherwise.]]
         }
      }
      reset @internal {
         [[Reset the values of a given prefs widget to a previous state.

           As can be seen on #Elm_Prefs_Reset_Mode, there are two possible
           actions to be taken by this call -- either to reset $prefs'
           values to the defaults (declared on the $.epb file it is bound
           to) or to reset to the state they were before the last modification
           it got.

           @since 1.8]]

         params {
            @in mode: Elm_Prefs_Reset_Mode; [[The reset mode to apply on $prefs]]
         }
      }
      item_value_set @internal {
         [[Set the value on a given prefs widget's item.

           This will change the value of item named $name programatically.

           @since 1.8]]

         return: bool; [[$true, on success, $false otherwise]]
         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection)]]
            @in value: const(Eina_Value)*; [[The value to set on the item. It should be typed as the item expects, preferably, or a conversion will take place]]
         }
      }
      item_value_get @const {
         [[Get the value of a given prefs widget's item.

           This will retrieve the value of item named $name.

           @since 1.8]]
         return: bool; [[$true, on success, $false otherwise]]

         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get value from]]
            @out value: Eina_Value; [[Where to store the value of the item. It will be overwritten and setup with the type the item is bound to]]
         }
      }
      item_object_get @internal {
         [[Get the Elementary widget bound to a given prefs widget's item.

           This will retrieve a handle to the real widget implementing a given
           item of $prefs, <b>for read-only</b> actions.

           Warning: You should never modify the state of the returned
           widget, because it's meant to be managed by $prefs, solely.

           @since 1.8]]

         return: const(Evas.Object)*; [[A valid widget handle, on success, or $NULL, otherwise]]
         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get object from]]
         }
      }
      item_disabled_set @internal {
         [[Set whether the widget bound to a given prefs widget's item is disabled or not.

           @since 1.8]]

         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to act on]]
            @in disabled: bool; [[$true, to make it disabled, $false otherwise]]
         }
      }
      item_disabled_get @const {
         [[Get whether the widget bound to a given prefs widget's item is disabled or not.

           @since 1.8]]
         return: bool; [[$true, if it is disabled, $false otherwise]]
         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get disabled state from]]
         }
      }
      item_swallow @internal {
         [["Swallows" an object into a SWALLOW item of a prefs widget.

           @since 1.8]]

         return: bool; [[$true, on success, $false otherwise]]
         params {
            @in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
            @in child: Evas.Object *; [[The object to occupy the item]]
         }
      }
      item_editable_set @internal {
         [[Set whether the widget bound to a given prefs widget's item is editable or not.

           Note: Only $TEXT or $TEXTAREA items' default widgets implement
           the 'editable' property. Custom registered widgets may as well
           implement them.

           @since 1.8]]

         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to act on]]
            @in editable: bool; [[$true, to make it editable, $false otherwise]]
         }
      }
      item_editable_get @const {
         [[Get whether the widget bound to a given prefs widget's item is editable or not.

           @since 1.8]]
         return: bool; [[$true, if it is editable, $false otherwise]]
         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get editable state from]]
         }
      }
      item_unswallow @internal {
         [[Unswallow an object from a SWALLOW item of a prefs widget.

           @since 1.8]]

         return: Evas.Object *; [[The unswallowed object, or NULL on errors]]
         params {
            @in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
         }
      }
      item_visible_set @internal {
         [[Set whether the widget bound to given prefs widget's item should be visible or not.

           Each prefs item may have a default visibility state, declared on
           the $.epb $prefs it was loaded with. By this call one may alter
           that state, programatically.

           @since 1.8]]

         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to change visibility of]]
            @in visible: bool; [[$true, to make it visible, $false otherwise]]
         }
      }
      item_visible_get @const {
         [[Get whether the widget bound to a given prefs widget's item is visible or not.

           @since 1.8]]
         return: bool; [[$true, if it is visible, $false otherwise]]
         params {
            @in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get visibility state from]]
         }
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Efl.File.file.set;
      Efl.File.file.get;
      Evas.Object_Smart.del;
      Evas.Object_Smart.add;
      Elm.Widget.focus_next;
   }
   events {
      page,changed; [[s]]
      page,saved; [[s]]
      page,reset; [[s]]
      page,loaded; [[s]]
      item,changed; [[s]]
      action; [[ss]]
   }

}
