efl/src/lib/efl/interfaces/efl_model_base.eo

struct Efl.Model.Property_Event {
     changed_properties: array<const(char) *> *; [[List of changed properties]]
     invalidated_properties: array<const(char) *> *; [[Removed properties identified by name]]
}

interface Efl.Model.Base ()
{
   legacy_prefix: null;
   eo_prefix: efl_model;
      methods {
         @property properties {
            get {
               [[Get properties from model.

                 properties_get is due to provide callers a way the fetch the
                 current properties implemented/used by the model. The event
                 EFL_MODEL_EVENT_PROPERTIES_CHANGE will be raised to notify
                 listeners of any modifications in the properties.

                 See also \@ref EFL_MODEL_EVENT_PROPERTIES_CHANGE.

                 @since 1.14
               ]]
         }
         values {
               properties: const(array<const(char)*>)*; [[array of current properties]]
            }
        }
        property_set {
           [[Set a property value of a given property name.

             The caller must ensure to call at least efl_model_prop_list
             before being able to see/set properties. This function sets
             a new property value into given property name. Once the
             operation is completed the concrete implementation should
             raise EFL_MODEL_EVENT_PROPERTIES_CHANGE event in order to
             notify listeners of the new value of the property.

             If the model doesn't have the property then there are two
             possibilities, either raise an error or create the new
             property in model

             See @.property_get, \@ref EFL_MODEL_EVENT_PROPERTIES_CHANGE

             @since 1.14
            ]]
           params {
               @in property: const(char)*; [[Property name]]
               @in value: const(generic_value)*; [[New value]]
               @inout promise: promise<generic_value>*; [[Promise returning the recorded value or error]]
           }
        }
        property_get {
           [[Retrieve the value of a given property name.

             At this point the caller is free to get values from properties.
             The event EFL_MODEL_EVENT_PROPERTIES_CHANGE may be raised to
             notify listeners of the property/value.

             See @.properties.get, \@ref EFL_MODEL_EVENT_PROPERTIES_CHANGE

             @since 1.14
           ]]
           params {
               @in property: const(char)*; [[Property name]]
               @inout value: promise<generic_value>*; [[Promise of the value that was got]]
           }
        }
        children_slice_get {
               [[Get children slice OR full range.

                 children_slice_get behaves in two different ways, it may
                 provide the slice if both $start AND $count are non-zero
                 OR full range otherwise.

                 Since 'slice' is a range, for example if we have 20 childs a
                 slice could be the range from 3(start) to 4(count), see:

                 child 0  [no]
                 child 1  [no]
                 child 2  [yes]
                 child 3  [yes]
                 child 4  [yes]
                 child 5  [yes]
                 child 6  [no]
                 child 7  [no]

                 Optionally the user can call children_count_get to know the
                 number of children so a valid range can be known in advance.

                 See @.children_count_get

                 @since 1.14
               ]]
            params {
                @in start: uint; [[Range begin - start from here. If start and
                               count are 0 slice is ignored.]]
                @in count: uint; [[Range size. If count and start are 0 slice is
                               ignored.]]
                @inout promise: promise<accessor<list<Eo.Base*>*>*>*; [[Promise of the children]]
            }
         }
         children_count_get {
                [[Get children count.

                  When efl_model_load is completed efl_model_coildren_count_get
                  can be use to get the number of children. children_count_get
                  can also be used before calling children_slice_get so a valid
                  range is known. Event EFL_MODEL_CHILDREN_COUNT_CHANGED is
                  emitted when count is finished.

                  See also @.children_slice_get.

                  @since 1.14
                ]]
            params {
                @inout promise: promise<uint>*;
            }
         }
         child_add {
            [[Add a new child.

              Add a new child, possibly dummy, depending on the implementation,
              of a internal keeping. When the child is effectively
              added the event \@ref EFL_MODEL_EVENT_CHILD_ADD is then raised
              and the new child is kept along with other children.

              @since 1.14
            ]]
            return: Eo.Base *;
         }
         child_del {
            [[Remove a child.

              Remove a child of a internal keeping. When the child is effectively
              removed the event \@ref EFL_MODEL_EVENT_CHILD_REMOVED is then
              raised to give a chance for listeners to perform any cleanup
              and/or update references.

              @since 1.14
            ]]
            params {
               @in child: Eo.Base*; [[Child to be removed]]
            }
         }
      }

   events {
      properties,changed: Efl.Model.Property_Event; [[Event dispatched when
                                                      properties list is
                                                      available.]]
      child,added; [[Event dispatched when new child is added.]]
      child,removed; [[Event dispatched when child is removed.]]
      children,count,changed; [[Event dispatched when children count is finished.]]
   }
}