internals/src/EflSharp/EflSharp/efl/efl_model.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 /// <summary>Efl model interface</summary>
  11 [Efl.IModelConcrete.NativeMethods]
  12 [Efl.Eo.BindingEntity]
  13 public interface IModel :
  14     Efl.Eo.IWrapper, IDisposable
  15 {
  16     /// <summary>Get properties from model.
  17 /// properties_get is due to provide callers a way the fetch the current properties implemented/used by the model. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> will be raised to notify listeners of any modifications in the properties.
  18 ///
  19 /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
  20 /// <returns>Array of current properties</returns>
  21 Eina.Iterator<System.String> GetProperties();
  22     /// <summary>Retrieve the value of a given property name.
  23 /// At this point the caller is free to get values from properties. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> may be raised to notify listeners of the property/value.
  24 ///
  25 /// See <see cref="Efl.IModel.GetProperties"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
  26 /// <param name="property">Property name</param>
  27 /// <returns>Property value</returns>
  28 Eina.Value GetProperty(System.String property);
  29     /// <summary>Set a property value of a given property name.
  30 /// 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 <see cref="Efl.IModel.PropertiesChangedEvt"/> event in order to notify listeners of the new value of the property.
  31 ///
  32 /// If the model doesn&apos;t have the property then there are two possibilities, either raise an error or create the new property in model
  33 ///
  34 /// See <see cref="Efl.IModel.GetProperty"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
  35 /// <param name="property">Property name</param>
  36 /// <param name="value">Property value</param>
  37 /// <returns>Return an error in case the property could not be set, the value that was set otherwise.</returns>
  38  Eina.Future SetProperty(System.String property, Eina.Value value);
  39     /// <summary>Get children count.
  40 /// When efl_model_load is completed <see cref="Efl.IModel.GetChildrenCount"/> can be used to get the number of children. <see cref="Efl.IModel.GetChildrenCount"/> can also be used before calling <see cref="Efl.IModel.GetChildrenSlice"/> so a valid range is known. Event <see cref="Efl.IModel.ChildrenCountChangedEvt"/> is emitted when count is finished.
  41 ///
  42 /// See also <see cref="Efl.IModel.GetChildrenSlice"/>.</summary>
  43 /// <returns>Current known children count</returns>
  44 uint GetChildrenCount();
  45     /// <summary>Get a future value when it changes to something that is not error:EAGAIN
  46 /// <see cref="Efl.IModel.GetProperty"/> can return an error with code EAGAIN when it doesn&apos;t have any meaningful value. To make life easier, this future will resolve when the error:EAGAIN disapears. Either into a failed future in case the error code changed to something else or a success with the value of the property whenever the property finally changes.
  47 ///
  48 /// The future can also be canceled if the model itself gets destroyed.</summary>
  49 /// <param name="property">Property name.</param>
  50 /// <returns>Future to be resolved when the property changes to anything other than error:EAGAIN</returns>
  51  Eina.Future GetPropertyReady(System.String property);
  52     /// <summary>Get children slice OR full range.
  53 /// <see cref="Efl.IModel.GetChildrenSlice"/> behaves in two different ways, it may provide the slice if <c>count</c> is non-zero OR full range otherwise.
  54 ///
  55 /// Since &apos;slice&apos; is a range, for example if we have 20 children a slice could be the range from 3(start) with 4(count), see:
  56 ///
  57 /// child 0  [no] child 1  [no] child 2  [no] child 3  [yes] child 4  [yes] child 5  [yes] child 6  [yes] child 7  [no]
  58 ///
  59 /// Optionally the user can call <see cref="Efl.IModel.GetChildrenCount"/> to know the number of children so a valid range can be known in advance.
  60 ///
  61 /// See <see cref="Efl.IModel.GetChildrenCount"/>
  62 ///
  63 /// Note: The returned children will live only as long as the future itself. Once the future is done, if you want to keep the object alive, you need to take a reference for yourself.</summary>
  64 /// <param name="start">Range begin - start from here.</param>
  65 /// <param name="count">Range size. If count is 0, start is ignored.</param>
  66 /// <returns>Array of children</returns>
  67  Eina.Future GetChildrenSlice(uint start, uint count);
  68     /// <summary>Add a new child.
  69 /// Add a new child, possibly dummy, depending on the implementation, of a internal keeping. When the child is effectively added the event <see cref="Efl.IModel.ChildAddedEvt"/> is then raised and the new child is kept along with other children.</summary>
  70 /// <returns>Child object</returns>
  71 Efl.Object AddChild();
  72     /// <summary>Remove a child.
  73 /// Remove a child of a internal keeping. When the child is effectively removed the event <see cref="Efl.IModel.ChildRemovedEvt"/> is then raised to give a chance for listeners to perform any cleanup and/or update references.</summary>
  74 /// <param name="child">Child to be removed</param>
  75 void DelChild(Efl.Object child);
  76                 /// <summary>Async wrapper for <see cref="SetProperty" />.</summary>
  77     /// <param name="property">Property name</param>
  78     /// <param name="value">Property value</param>
  79     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
  80     /// <returns>An async task wrapping the result of the operation.</returns>
  81     System.Threading.Tasks.Task<Eina.Value> SetPropertyAsync(System.String property,Eina.Value value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
  82
  83             /// <summary>Async wrapper for <see cref="GetPropertyReady" />.</summary>
  84     /// <param name="property">Property name.</param>
  85     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
  86     /// <returns>An async task wrapping the result of the operation.</returns>
  87     System.Threading.Tasks.Task<Eina.Value> GetPropertyReadyAsync(System.String property, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
  88
  89         /// <summary>Async wrapper for <see cref="GetChildrenSlice" />.</summary>
  90     /// <param name="start">Range begin - start from here.</param>
  91     /// <param name="count">Range size. If count is 0, start is ignored.</param>
  92     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
  93     /// <returns>An async task wrapping the result of the operation.</returns>
  94     System.Threading.Tasks.Task<Eina.Value> GetChildrenSliceAsync(uint start,uint count, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
  95
  96             /// <summary>Event dispatched when properties list is available.</summary>
  97     event EventHandler<Efl.IModelPropertiesChangedEvt_Args> PropertiesChangedEvt;
  98     /// <summary>Event dispatched when new child is added.</summary>
  99     event EventHandler<Efl.IModelChildAddedEvt_Args> ChildAddedEvt;
 100     /// <summary>Event dispatched when child is removed.</summary>
 101     event EventHandler<Efl.IModelChildRemovedEvt_Args> ChildRemovedEvt;
 102     /// <summary>Event dispatched when children count is finished.</summary>
 103     event EventHandler ChildrenCountChangedEvt;
 104     /// <summary>Get properties from model.
 105     /// properties_get is due to provide callers a way the fetch the current properties implemented/used by the model. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> will be raised to notify listeners of any modifications in the properties.
 106     ///
 107     /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 108     /// <value>Array of current properties</value>
 109     Eina.Iterator<System.String> Properties {
 110         get ;
 111     }
 112     /// <summary>Get children count.
 113     /// When efl_model_load is completed <see cref="Efl.IModel.GetChildrenCount"/> can be used to get the number of children. <see cref="Efl.IModel.GetChildrenCount"/> can also be used before calling <see cref="Efl.IModel.GetChildrenSlice"/> so a valid range is known. Event <see cref="Efl.IModel.ChildrenCountChangedEvt"/> is emitted when count is finished.
 114     ///
 115     /// See also <see cref="Efl.IModel.GetChildrenSlice"/>.</summary>
 116     /// <value>Current known children count</value>
 117     uint ChildrenCount {
 118         get ;
 119     }
 120 }
 121 ///<summary>Event argument wrapper for event <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 122 [Efl.Eo.BindingEntity]
 123 public class IModelPropertiesChangedEvt_Args : EventArgs {
 124     ///<summary>Actual event payload.</summary>
 125     public Efl.ModelPropertyEvent arg { get; set; }
 126 }
 127 ///<summary>Event argument wrapper for event <see cref="Efl.IModel.ChildAddedEvt"/>.</summary>
 128 [Efl.Eo.BindingEntity]
 129 public class IModelChildAddedEvt_Args : EventArgs {
 130     ///<summary>Actual event payload.</summary>
 131     public Efl.ModelChildrenEvent arg { get; set; }
 132 }
 133 ///<summary>Event argument wrapper for event <see cref="Efl.IModel.ChildRemovedEvt"/>.</summary>
 134 [Efl.Eo.BindingEntity]
 135 public class IModelChildRemovedEvt_Args : EventArgs {
 136     ///<summary>Actual event payload.</summary>
 137     public Efl.ModelChildrenEvent arg { get; set; }
 138 }
 139 /// <summary>Efl model interface</summary>
 140 sealed public class IModelConcrete :
 141     Efl.Eo.EoWrapper
 142     , IModel
 143
 144 {
 145     ///<summary>Pointer to the native class description.</summary>
 146     public override System.IntPtr NativeClass
 147     {
 148         get
 149         {
 150             if (((object)this).GetType() == typeof(IModelConcrete))
 151             {
 152                 return GetEflClassStatic();
 153             }
 154             else
 155             {
 156                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 157             }
 158         }
 159     }
 160
 161     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 162     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 163     private IModelConcrete(ConstructingHandle ch) : base(ch)
 164     {
 165     }
 166
 167     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 168         efl_model_interface_get();
 169     /// <summary>Initializes a new instance of the <see cref="IModel"/> class.
 170     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 171     /// <param name="wh">The native pointer to be wrapped.</param>
 172     private IModelConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 173     {
 174     }
 175
 176     /// <summary>Event dispatched when properties list is available.</summary>
 177     public event EventHandler<Efl.IModelPropertiesChangedEvt_Args> PropertiesChangedEvt
 178     {
 179         add
 180         {
 181             lock (eflBindingEventLock)
 182             {
 183                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 184                 {
 185                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 186                     if (obj != null)
 187                     {
 188                         Efl.IModelPropertiesChangedEvt_Args args = new Efl.IModelPropertiesChangedEvt_Args();
 189                         args.arg =  evt.Info;
 190                         try
 191                         {
 192                             value?.Invoke(obj, args);
 193                         }
 194                         catch (Exception e)
 195                         {
 196                             Eina.Log.Error(e.ToString());
 197                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 198                         }
 199                     }
 200                 };
 201
 202                 string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
 203                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 204             }
 205         }
 206
 207         remove
 208         {
 209             lock (eflBindingEventLock)
 210             {
 211                 string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
 212                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 213             }
 214         }
 215     }
 216     ///<summary>Method to raise event PropertiesChangedEvt.</summary>
 217     public void OnPropertiesChangedEvt(Efl.IModelPropertiesChangedEvt_Args e)
 218     {
 219         var key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
 220         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 221         if (desc == IntPtr.Zero)
 222         {
 223             Eina.Log.Error($"Failed to get native event {key}");
 224             return;
 225         }
 226
 227         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 228         try
 229         {
 230             Marshal.StructureToPtr(e.arg, info, false);
 231             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 232         }
 233         finally
 234         {
 235             Marshal.FreeHGlobal(info);
 236         }
 237     }
 238     /// <summary>Event dispatched when new child is added.</summary>
 239     public event EventHandler<Efl.IModelChildAddedEvt_Args> ChildAddedEvt
 240     {
 241         add
 242         {
 243             lock (eflBindingEventLock)
 244             {
 245                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 246                 {
 247                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 248                     if (obj != null)
 249                     {
 250                         Efl.IModelChildAddedEvt_Args args = new Efl.IModelChildAddedEvt_Args();
 251                         args.arg =  evt.Info;
 252                         try
 253                         {
 254                             value?.Invoke(obj, args);
 255                         }
 256                         catch (Exception e)
 257                         {
 258                             Eina.Log.Error(e.ToString());
 259                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 260                         }
 261                     }
 262                 };
 263
 264                 string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 265                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 266             }
 267         }
 268
 269         remove
 270         {
 271             lock (eflBindingEventLock)
 272             {
 273                 string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 274                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 275             }
 276         }
 277     }
 278     ///<summary>Method to raise event ChildAddedEvt.</summary>
 279     public void OnChildAddedEvt(Efl.IModelChildAddedEvt_Args e)
 280     {
 281         var key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 282         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 283         if (desc == IntPtr.Zero)
 284         {
 285             Eina.Log.Error($"Failed to get native event {key}");
 286             return;
 287         }
 288
 289         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 290         try
 291         {
 292             Marshal.StructureToPtr(e.arg, info, false);
 293             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 294         }
 295         finally
 296         {
 297             Marshal.FreeHGlobal(info);
 298         }
 299     }
 300     /// <summary>Event dispatched when child is removed.</summary>
 301     public event EventHandler<Efl.IModelChildRemovedEvt_Args> ChildRemovedEvt
 302     {
 303         add
 304         {
 305             lock (eflBindingEventLock)
 306             {
 307                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 308                 {
 309                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 310                     if (obj != null)
 311                     {
 312                         Efl.IModelChildRemovedEvt_Args args = new Efl.IModelChildRemovedEvt_Args();
 313                         args.arg =  evt.Info;
 314                         try
 315                         {
 316                             value?.Invoke(obj, args);
 317                         }
 318                         catch (Exception e)
 319                         {
 320                             Eina.Log.Error(e.ToString());
 321                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 322                         }
 323                     }
 324                 };
 325
 326                 string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 327                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 328             }
 329         }
 330
 331         remove
 332         {
 333             lock (eflBindingEventLock)
 334             {
 335                 string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 336                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 337             }
 338         }
 339     }
 340     ///<summary>Method to raise event ChildRemovedEvt.</summary>
 341     public void OnChildRemovedEvt(Efl.IModelChildRemovedEvt_Args e)
 342     {
 343         var key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 344         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 345         if (desc == IntPtr.Zero)
 346         {
 347             Eina.Log.Error($"Failed to get native event {key}");
 348             return;
 349         }
 350
 351         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 352         try
 353         {
 354             Marshal.StructureToPtr(e.arg, info, false);
 355             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 356         }
 357         finally
 358         {
 359             Marshal.FreeHGlobal(info);
 360         }
 361     }
 362     /// <summary>Event dispatched when children count is finished.</summary>
 363     public event EventHandler ChildrenCountChangedEvt
 364     {
 365         add
 366         {
 367             lock (eflBindingEventLock)
 368             {
 369                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 370                 {
 371                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 372                     if (obj != null)
 373                     {
 374                         EventArgs args = EventArgs.Empty;
 375                         try
 376                         {
 377                             value?.Invoke(obj, args);
 378                         }
 379                         catch (Exception e)
 380                         {
 381                             Eina.Log.Error(e.ToString());
 382                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 383                         }
 384                     }
 385                 };
 386
 387                 string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 388                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 389             }
 390         }
 391
 392         remove
 393         {
 394             lock (eflBindingEventLock)
 395             {
 396                 string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 397                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 398             }
 399         }
 400     }
 401     ///<summary>Method to raise event ChildrenCountChangedEvt.</summary>
 402     public void OnChildrenCountChangedEvt(EventArgs e)
 403     {
 404         var key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 405         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 406         if (desc == IntPtr.Zero)
 407         {
 408             Eina.Log.Error($"Failed to get native event {key}");
 409             return;
 410         }
 411
 412         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 413     }
 414     /// <summary>Get properties from model.
 415     /// properties_get is due to provide callers a way the fetch the current properties implemented/used by the model. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> will be raised to notify listeners of any modifications in the properties.
 416     ///
 417     /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 418     /// <returns>Array of current properties</returns>
 419     public Eina.Iterator<System.String> GetProperties() {
 420          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_properties_get_ptr.Value.Delegate(this.NativeHandle);
 421         Eina.Error.RaiseIfUnhandledException();
 422         return new Eina.Iterator<System.String>(_ret_var, true);
 423  }
 424     /// <summary>Retrieve the value of a given property name.
 425     /// At this point the caller is free to get values from properties. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> may be raised to notify listeners of the property/value.
 426     ///
 427     /// See <see cref="Efl.IModel.GetProperties"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
 428     /// <param name="property">Property name</param>
 429     /// <returns>Property value</returns>
 430     public Eina.Value GetProperty(System.String property) {
 431                                  var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_get_ptr.Value.Delegate(this.NativeHandle,property);
 432         Eina.Error.RaiseIfUnhandledException();
 433                         return _ret_var;
 434  }
 435     /// <summary>Set a property value of a given property name.
 436     /// 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 <see cref="Efl.IModel.PropertiesChangedEvt"/> event in order to notify listeners of the new value of the property.
 437     ///
 438     /// If the model doesn&apos;t have the property then there are two possibilities, either raise an error or create the new property in model
 439     ///
 440     /// See <see cref="Efl.IModel.GetProperty"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
 441     /// <param name="property">Property name</param>
 442     /// <param name="value">Property value</param>
 443     /// <returns>Return an error in case the property could not be set, the value that was set otherwise.</returns>
 444     public  Eina.Future SetProperty(System.String property, Eina.Value value) {
 445                                                          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_set_ptr.Value.Delegate(this.NativeHandle,property, value);
 446         Eina.Error.RaiseIfUnhandledException();
 447                                         return _ret_var;
 448  }
 449     /// <summary>Get children count.
 450     /// When efl_model_load is completed <see cref="Efl.IModel.GetChildrenCount"/> can be used to get the number of children. <see cref="Efl.IModel.GetChildrenCount"/> can also be used before calling <see cref="Efl.IModel.GetChildrenSlice"/> so a valid range is known. Event <see cref="Efl.IModel.ChildrenCountChangedEvt"/> is emitted when count is finished.
 451     ///
 452     /// See also <see cref="Efl.IModel.GetChildrenSlice"/>.</summary>
 453     /// <returns>Current known children count</returns>
 454     public uint GetChildrenCount() {
 455          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_children_count_get_ptr.Value.Delegate(this.NativeHandle);
 456         Eina.Error.RaiseIfUnhandledException();
 457         return _ret_var;
 458  }
 459     /// <summary>Get a future value when it changes to something that is not error:EAGAIN
 460     /// <see cref="Efl.IModel.GetProperty"/> can return an error with code EAGAIN when it doesn&apos;t have any meaningful value. To make life easier, this future will resolve when the error:EAGAIN disapears. Either into a failed future in case the error code changed to something else or a success with the value of the property whenever the property finally changes.
 461     ///
 462     /// The future can also be canceled if the model itself gets destroyed.</summary>
 463     /// <param name="property">Property name.</param>
 464     /// <returns>Future to be resolved when the property changes to anything other than error:EAGAIN</returns>
 465     public  Eina.Future GetPropertyReady(System.String property) {
 466                                  var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_ready_get_ptr.Value.Delegate(this.NativeHandle,property);
 467         Eina.Error.RaiseIfUnhandledException();
 468                         return _ret_var;
 469  }
 470     /// <summary>Get children slice OR full range.
 471     /// <see cref="Efl.IModel.GetChildrenSlice"/> behaves in two different ways, it may provide the slice if <c>count</c> is non-zero OR full range otherwise.
 472     ///
 473     /// Since &apos;slice&apos; is a range, for example if we have 20 children a slice could be the range from 3(start) with 4(count), see:
 474     ///
 475     /// child 0  [no] child 1  [no] child 2  [no] child 3  [yes] child 4  [yes] child 5  [yes] child 6  [yes] child 7  [no]
 476     ///
 477     /// Optionally the user can call <see cref="Efl.IModel.GetChildrenCount"/> to know the number of children so a valid range can be known in advance.
 478     ///
 479     /// See <see cref="Efl.IModel.GetChildrenCount"/>
 480     ///
 481     /// Note: The returned children will live only as long as the future itself. Once the future is done, if you want to keep the object alive, you need to take a reference for yourself.</summary>
 482     /// <param name="start">Range begin - start from here.</param>
 483     /// <param name="count">Range size. If count is 0, start is ignored.</param>
 484     /// <returns>Array of children</returns>
 485     public  Eina.Future GetChildrenSlice(uint start, uint count) {
 486                                                          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_children_slice_get_ptr.Value.Delegate(this.NativeHandle,start, count);
 487         Eina.Error.RaiseIfUnhandledException();
 488                                         return _ret_var;
 489  }
 490     /// <summary>Add a new child.
 491     /// Add a new child, possibly dummy, depending on the implementation, of a internal keeping. When the child is effectively added the event <see cref="Efl.IModel.ChildAddedEvt"/> is then raised and the new child is kept along with other children.</summary>
 492     /// <returns>Child object</returns>
 493     public Efl.Object AddChild() {
 494          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_child_add_ptr.Value.Delegate(this.NativeHandle);
 495         Eina.Error.RaiseIfUnhandledException();
 496         return _ret_var;
 497  }
 498     /// <summary>Remove a child.
 499     /// Remove a child of a internal keeping. When the child is effectively removed the event <see cref="Efl.IModel.ChildRemovedEvt"/> is then raised to give a chance for listeners to perform any cleanup and/or update references.</summary>
 500     /// <param name="child">Child to be removed</param>
 501     public void DelChild(Efl.Object child) {
 502                                  Efl.IModelConcrete.NativeMethods.efl_model_child_del_ptr.Value.Delegate(this.NativeHandle,child);
 503         Eina.Error.RaiseIfUnhandledException();
 504                          }
 505     /// <summary>Async wrapper for <see cref="SetProperty" />.</summary>
 506     /// <param name="property">Property name</param>
 507     /// <param name="value">Property value</param>
 508     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 509     /// <returns>An async task wrapping the result of the operation.</returns>
 510     public System.Threading.Tasks.Task<Eina.Value> SetPropertyAsync(System.String property,Eina.Value value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 511     {
 512         Eina.Future future = SetProperty( property, value);
 513         return Efl.Eo.Globals.WrapAsync(future, token);
 514     }
 515
 516     /// <summary>Async wrapper for <see cref="GetPropertyReady" />.</summary>
 517     /// <param name="property">Property name.</param>
 518     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 519     /// <returns>An async task wrapping the result of the operation.</returns>
 520     public System.Threading.Tasks.Task<Eina.Value> GetPropertyReadyAsync(System.String property, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 521     {
 522         Eina.Future future = GetPropertyReady( property);
 523         return Efl.Eo.Globals.WrapAsync(future, token);
 524     }
 525
 526     /// <summary>Async wrapper for <see cref="GetChildrenSlice" />.</summary>
 527     /// <param name="start">Range begin - start from here.</param>
 528     /// <param name="count">Range size. If count is 0, start is ignored.</param>
 529     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 530     /// <returns>An async task wrapping the result of the operation.</returns>
 531     public System.Threading.Tasks.Task<Eina.Value> GetChildrenSliceAsync(uint start,uint count, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 532     {
 533         Eina.Future future = GetChildrenSlice( start, count);
 534         return Efl.Eo.Globals.WrapAsync(future, token);
 535     }
 536
 537     /// <summary>Get properties from model.
 538     /// properties_get is due to provide callers a way the fetch the current properties implemented/used by the model. The event <see cref="Efl.IModel.PropertiesChangedEvt"/> will be raised to notify listeners of any modifications in the properties.
 539     ///
 540     /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 541     /// <value>Array of current properties</value>
 542     public Eina.Iterator<System.String> Properties {
 543         get { return GetProperties(); }
 544     }
 545     /// <summary>Get children count.
 546     /// When efl_model_load is completed <see cref="Efl.IModel.GetChildrenCount"/> can be used to get the number of children. <see cref="Efl.IModel.GetChildrenCount"/> can also be used before calling <see cref="Efl.IModel.GetChildrenSlice"/> so a valid range is known. Event <see cref="Efl.IModel.ChildrenCountChangedEvt"/> is emitted when count is finished.
 547     ///
 548     /// See also <see cref="Efl.IModel.GetChildrenSlice"/>.</summary>
 549     /// <value>Current known children count</value>
 550     public uint ChildrenCount {
 551         get { return GetChildrenCount(); }
 552     }
 553     private static IntPtr GetEflClassStatic()
 554     {
 555         return Efl.IModelConcrete.efl_model_interface_get();
 556     }
 557     /// <summary>Wrapper for native methods and virtual method delegates.
 558     /// For internal use by generated code only.</summary>
 559     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 560     {
 561         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 562         /// <summary>Gets the list of Eo operations to override.</summary>
 563         /// <returns>The list of Eo operations to be overload.</returns>
 564         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 565         {
 566             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 567             var methods = Efl.Eo.Globals.GetUserMethods(type);
 568
 569             if (efl_model_properties_get_static_delegate == null)
 570             {
 571                 efl_model_properties_get_static_delegate = new efl_model_properties_get_delegate(properties_get);
 572             }
 573
 574             if (methods.FirstOrDefault(m => m.Name == "GetProperties") != null)
 575             {
 576                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_properties_get"), func = Marshal.GetFunctionPointerForDelegate(efl_model_properties_get_static_delegate) });
 577             }
 578
 579             if (efl_model_property_get_static_delegate == null)
 580             {
 581                 efl_model_property_get_static_delegate = new efl_model_property_get_delegate(property_get);
 582             }
 583
 584             if (methods.FirstOrDefault(m => m.Name == "GetProperty") != null)
 585             {
 586                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_property_get"), func = Marshal.GetFunctionPointerForDelegate(efl_model_property_get_static_delegate) });
 587             }
 588
 589             if (efl_model_property_set_static_delegate == null)
 590             {
 591                 efl_model_property_set_static_delegate = new efl_model_property_set_delegate(property_set);
 592             }
 593
 594             if (methods.FirstOrDefault(m => m.Name == "SetProperty") != null)
 595             {
 596                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_property_set"), func = Marshal.GetFunctionPointerForDelegate(efl_model_property_set_static_delegate) });
 597             }
 598
 599             if (efl_model_children_count_get_static_delegate == null)
 600             {
 601                 efl_model_children_count_get_static_delegate = new efl_model_children_count_get_delegate(children_count_get);
 602             }
 603
 604             if (methods.FirstOrDefault(m => m.Name == "GetChildrenCount") != null)
 605             {
 606                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_children_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_model_children_count_get_static_delegate) });
 607             }
 608
 609             if (efl_model_property_ready_get_static_delegate == null)
 610             {
 611                 efl_model_property_ready_get_static_delegate = new efl_model_property_ready_get_delegate(property_ready_get);
 612             }
 613
 614             if (methods.FirstOrDefault(m => m.Name == "GetPropertyReady") != null)
 615             {
 616                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_property_ready_get"), func = Marshal.GetFunctionPointerForDelegate(efl_model_property_ready_get_static_delegate) });
 617             }
 618
 619             if (efl_model_children_slice_get_static_delegate == null)
 620             {
 621                 efl_model_children_slice_get_static_delegate = new efl_model_children_slice_get_delegate(children_slice_get);
 622             }
 623
 624             if (methods.FirstOrDefault(m => m.Name == "GetChildrenSlice") != null)
 625             {
 626                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_children_slice_get"), func = Marshal.GetFunctionPointerForDelegate(efl_model_children_slice_get_static_delegate) });
 627             }
 628
 629             if (efl_model_child_add_static_delegate == null)
 630             {
 631                 efl_model_child_add_static_delegate = new efl_model_child_add_delegate(child_add);
 632             }
 633
 634             if (methods.FirstOrDefault(m => m.Name == "AddChild") != null)
 635             {
 636                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_child_add"), func = Marshal.GetFunctionPointerForDelegate(efl_model_child_add_static_delegate) });
 637             }
 638
 639             if (efl_model_child_del_static_delegate == null)
 640             {
 641                 efl_model_child_del_static_delegate = new efl_model_child_del_delegate(child_del);
 642             }
 643
 644             if (methods.FirstOrDefault(m => m.Name == "DelChild") != null)
 645             {
 646                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_model_child_del"), func = Marshal.GetFunctionPointerForDelegate(efl_model_child_del_static_delegate) });
 647             }
 648
 649             return descs;
 650         }
 651         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 652         /// <returns>The native class pointer.</returns>
 653         public override IntPtr GetEflClass()
 654         {
 655             return Efl.IModelConcrete.efl_model_interface_get();
 656         }
 657
 658         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 659
 660
 661         private delegate System.IntPtr efl_model_properties_get_delegate(System.IntPtr obj, System.IntPtr pd);
 662
 663
 664         public delegate System.IntPtr efl_model_properties_get_api_delegate(System.IntPtr obj);
 665
 666         public static Efl.Eo.FunctionWrapper<efl_model_properties_get_api_delegate> efl_model_properties_get_ptr = new Efl.Eo.FunctionWrapper<efl_model_properties_get_api_delegate>(Module, "efl_model_properties_get");
 667
 668         private static System.IntPtr properties_get(System.IntPtr obj, System.IntPtr pd)
 669         {
 670             Eina.Log.Debug("function efl_model_properties_get was called");
 671             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 672             if (ws != null)
 673             {
 674             Eina.Iterator<System.String> _ret_var = default(Eina.Iterator<System.String>);
 675                 try
 676                 {
 677                     _ret_var = ((IModel)ws.Target).GetProperties();
 678                 }
 679                 catch (Exception e)
 680                 {
 681                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 682                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 683                 }
 684
 685         _ret_var.Own = false; return _ret_var.Handle;
 686
 687             }
 688             else
 689             {
 690                 return efl_model_properties_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 691             }
 692         }
 693
 694         private static efl_model_properties_get_delegate efl_model_properties_get_static_delegate;
 695
 696         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]
 697         private delegate Eina.Value efl_model_property_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property);
 698
 699         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]
 700         public delegate Eina.Value efl_model_property_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property);
 701
 702         public static Efl.Eo.FunctionWrapper<efl_model_property_get_api_delegate> efl_model_property_get_ptr = new Efl.Eo.FunctionWrapper<efl_model_property_get_api_delegate>(Module, "efl_model_property_get");
 703
 704         private static Eina.Value property_get(System.IntPtr obj, System.IntPtr pd, System.String property)
 705         {
 706             Eina.Log.Debug("function efl_model_property_get was called");
 707             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 708             if (ws != null)
 709             {
 710                                     Eina.Value _ret_var = default(Eina.Value);
 711                 try
 712                 {
 713                     _ret_var = ((IModel)ws.Target).GetProperty(property);
 714                 }
 715                 catch (Exception e)
 716                 {
 717                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 718                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 719                 }
 720
 721                         return _ret_var;
 722
 723             }
 724             else
 725             {
 726                 return efl_model_property_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property);
 727             }
 728         }
 729
 730         private static efl_model_property_get_delegate efl_model_property_get_static_delegate;
 731
 732         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 733         private delegate  Eina.Future efl_model_property_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))] Eina.Value value);
 734
 735         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 736         public delegate  Eina.Future efl_model_property_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))] Eina.Value value);
 737
 738         public static Efl.Eo.FunctionWrapper<efl_model_property_set_api_delegate> efl_model_property_set_ptr = new Efl.Eo.FunctionWrapper<efl_model_property_set_api_delegate>(Module, "efl_model_property_set");
 739
 740         private static  Eina.Future property_set(System.IntPtr obj, System.IntPtr pd, System.String property, Eina.Value value)
 741         {
 742             Eina.Log.Debug("function efl_model_property_set was called");
 743             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 744             if (ws != null)
 745             {
 746                                                              Eina.Future _ret_var = default( Eina.Future);
 747                 try
 748                 {
 749                     _ret_var = ((IModel)ws.Target).SetProperty(property, value);
 750                 }
 751                 catch (Exception e)
 752                 {
 753                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 754                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 755                 }
 756
 757                                         return _ret_var;
 758
 759             }
 760             else
 761             {
 762                 return efl_model_property_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property, value);
 763             }
 764         }
 765
 766         private static efl_model_property_set_delegate efl_model_property_set_static_delegate;
 767
 768
 769         private delegate uint efl_model_children_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 770
 771
 772         public delegate uint efl_model_children_count_get_api_delegate(System.IntPtr obj);
 773
 774         public static Efl.Eo.FunctionWrapper<efl_model_children_count_get_api_delegate> efl_model_children_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_model_children_count_get_api_delegate>(Module, "efl_model_children_count_get");
 775
 776         private static uint children_count_get(System.IntPtr obj, System.IntPtr pd)
 777         {
 778             Eina.Log.Debug("function efl_model_children_count_get was called");
 779             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 780             if (ws != null)
 781             {
 782             uint _ret_var = default(uint);
 783                 try
 784                 {
 785                     _ret_var = ((IModel)ws.Target).GetChildrenCount();
 786                 }
 787                 catch (Exception e)
 788                 {
 789                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 790                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 791                 }
 792
 793         return _ret_var;
 794
 795             }
 796             else
 797             {
 798                 return efl_model_children_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 799             }
 800         }
 801
 802         private static efl_model_children_count_get_delegate efl_model_children_count_get_static_delegate;
 803
 804         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 805         private delegate  Eina.Future efl_model_property_ready_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property);
 806
 807         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 808         public delegate  Eina.Future efl_model_property_ready_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property);
 809
 810         public static Efl.Eo.FunctionWrapper<efl_model_property_ready_get_api_delegate> efl_model_property_ready_get_ptr = new Efl.Eo.FunctionWrapper<efl_model_property_ready_get_api_delegate>(Module, "efl_model_property_ready_get");
 811
 812         private static  Eina.Future property_ready_get(System.IntPtr obj, System.IntPtr pd, System.String property)
 813         {
 814             Eina.Log.Debug("function efl_model_property_ready_get was called");
 815             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 816             if (ws != null)
 817             {
 818                                      Eina.Future _ret_var = default( Eina.Future);
 819                 try
 820                 {
 821                     _ret_var = ((IModel)ws.Target).GetPropertyReady(property);
 822                 }
 823                 catch (Exception e)
 824                 {
 825                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 826                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 827                 }
 828
 829                         return _ret_var;
 830
 831             }
 832             else
 833             {
 834                 return efl_model_property_ready_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property);
 835             }
 836         }
 837
 838         private static efl_model_property_ready_get_delegate efl_model_property_ready_get_static_delegate;
 839
 840         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 841         private delegate  Eina.Future efl_model_children_slice_get_delegate(System.IntPtr obj, System.IntPtr pd,  uint start,  uint count);
 842
 843         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 844         public delegate  Eina.Future efl_model_children_slice_get_api_delegate(System.IntPtr obj,  uint start,  uint count);
 845
 846         public static Efl.Eo.FunctionWrapper<efl_model_children_slice_get_api_delegate> efl_model_children_slice_get_ptr = new Efl.Eo.FunctionWrapper<efl_model_children_slice_get_api_delegate>(Module, "efl_model_children_slice_get");
 847
 848         private static  Eina.Future children_slice_get(System.IntPtr obj, System.IntPtr pd, uint start, uint count)
 849         {
 850             Eina.Log.Debug("function efl_model_children_slice_get was called");
 851             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 852             if (ws != null)
 853             {
 854                                                              Eina.Future _ret_var = default( Eina.Future);
 855                 try
 856                 {
 857                     _ret_var = ((IModel)ws.Target).GetChildrenSlice(start, count);
 858                 }
 859                 catch (Exception e)
 860                 {
 861                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 862                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 863                 }
 864
 865                                         return _ret_var;
 866
 867             }
 868             else
 869             {
 870                 return efl_model_children_slice_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, count);
 871             }
 872         }
 873
 874         private static efl_model_children_slice_get_delegate efl_model_children_slice_get_static_delegate;
 875
 876         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 877         private delegate Efl.Object efl_model_child_add_delegate(System.IntPtr obj, System.IntPtr pd);
 878
 879         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 880         public delegate Efl.Object efl_model_child_add_api_delegate(System.IntPtr obj);
 881
 882         public static Efl.Eo.FunctionWrapper<efl_model_child_add_api_delegate> efl_model_child_add_ptr = new Efl.Eo.FunctionWrapper<efl_model_child_add_api_delegate>(Module, "efl_model_child_add");
 883
 884         private static Efl.Object child_add(System.IntPtr obj, System.IntPtr pd)
 885         {
 886             Eina.Log.Debug("function efl_model_child_add was called");
 887             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 888             if (ws != null)
 889             {
 890             Efl.Object _ret_var = default(Efl.Object);
 891                 try
 892                 {
 893                     _ret_var = ((IModel)ws.Target).AddChild();
 894                 }
 895                 catch (Exception e)
 896                 {
 897                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 898                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 899                 }
 900
 901         return _ret_var;
 902
 903             }
 904             else
 905             {
 906                 return efl_model_child_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 907             }
 908         }
 909
 910         private static efl_model_child_add_delegate efl_model_child_add_static_delegate;
 911
 912
 913         private delegate void efl_model_child_del_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object child);
 914
 915
 916         public delegate void efl_model_child_del_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object child);
 917
 918         public static Efl.Eo.FunctionWrapper<efl_model_child_del_api_delegate> efl_model_child_del_ptr = new Efl.Eo.FunctionWrapper<efl_model_child_del_api_delegate>(Module, "efl_model_child_del");
 919
 920         private static void child_del(System.IntPtr obj, System.IntPtr pd, Efl.Object child)
 921         {
 922             Eina.Log.Debug("function efl_model_child_del was called");
 923             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 924             if (ws != null)
 925             {
 926
 927                 try
 928                 {
 929                     ((IModel)ws.Target).DelChild(child);
 930                 }
 931                 catch (Exception e)
 932                 {
 933                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 934                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 935                 }
 936
 937
 938             }
 939             else
 940             {
 941                 efl_model_child_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
 942             }
 943         }
 944
 945         private static efl_model_child_del_delegate efl_model_child_del_static_delegate;
 946
 947         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 948
 949 }
 950 }
 951 }
 952
 953 namespace Efl {
 954
 955 /// <summary>EFL model property event data structure</summary>
 956 [StructLayout(LayoutKind.Sequential)]
 957 [Efl.Eo.BindingEntity]
 958 public struct ModelPropertyEvent
 959 {
 960     /// <summary>List of changed properties</summary>
 961     public Eina.Array<Eina.Stringshare> Changed_properties;
 962     /// <summary>Removed properties identified by name</summary>
 963     public Eina.Array<Eina.Stringshare> Invalidated_properties;
 964     ///<summary>Constructor for ModelPropertyEvent.</summary>
 965     public ModelPropertyEvent(
 966         Eina.Array<Eina.Stringshare> Changed_properties = default(Eina.Array<Eina.Stringshare>),
 967         Eina.Array<Eina.Stringshare> Invalidated_properties = default(Eina.Array<Eina.Stringshare>)    )
 968     {
 969         this.Changed_properties = Changed_properties;
 970         this.Invalidated_properties = Invalidated_properties;
 971     }
 972
 973     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
 974     ///<param name="ptr">Native pointer to be converted.</param>
 975     public static implicit operator ModelPropertyEvent(IntPtr ptr)
 976     {
 977         var tmp = (ModelPropertyEvent.NativeStruct)Marshal.PtrToStructure(ptr, typeof(ModelPropertyEvent.NativeStruct));
 978         return tmp;
 979     }
 980
 981     #pragma warning disable CS1591
 982
 983     ///<summary>Internal wrapper for struct ModelPropertyEvent.</summary>
 984     [StructLayout(LayoutKind.Sequential)]
 985     public struct NativeStruct
 986     {
 987
 988         public System.IntPtr Changed_properties;
 989
 990         public System.IntPtr Invalidated_properties;
 991         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 992         public static implicit operator ModelPropertyEvent.NativeStruct(ModelPropertyEvent _external_struct)
 993         {
 994             var _internal_struct = new ModelPropertyEvent.NativeStruct();
 995             _internal_struct.Changed_properties = _external_struct.Changed_properties.Handle;
 996             _internal_struct.Invalidated_properties = _external_struct.Invalidated_properties.Handle;
 997             return _internal_struct;
 998         }
 999
1000         ///<summary>Implicit conversion to the managed representation.</summary>
1001         public static implicit operator ModelPropertyEvent(ModelPropertyEvent.NativeStruct _internal_struct)
1002         {
1003             var _external_struct = new ModelPropertyEvent();
1004             _external_struct.Changed_properties = new Eina.Array<Eina.Stringshare>(_internal_struct.Changed_properties, false, false);
1005             _external_struct.Invalidated_properties = new Eina.Array<Eina.Stringshare>(_internal_struct.Invalidated_properties, false, false);
1006             return _external_struct;
1007         }
1008
1009     }
1010
1011     #pragma warning restore CS1591
1012
1013 }
1014
1015 }
1016
1017 namespace Efl {
1018
1019 /// <summary>Every time a child is added the event <see cref="Efl.IModel.ChildAddedEvt"/> is dispatched passing along this structure.</summary>
1020 [StructLayout(LayoutKind.Sequential)]
1021 [Efl.Eo.BindingEntity]
1022 public struct ModelChildrenEvent
1023 {
1024     /// <summary>index is a hint and is intended to provide a way for applications to control/know children relative positions through listings.</summary>
1025     public uint Index;
1026     /// <summary>If an object has been built for this index and it is currently tracked by the parent, it will be available here.</summary>
1027     public Efl.Object Child;
1028     ///<summary>Constructor for ModelChildrenEvent.</summary>
1029     public ModelChildrenEvent(
1030         uint Index = default(uint),
1031         Efl.Object Child = default(Efl.Object)    )
1032     {
1033         this.Index = Index;
1034         this.Child = Child;
1035     }
1036
1037     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
1038     ///<param name="ptr">Native pointer to be converted.</param>
1039     public static implicit operator ModelChildrenEvent(IntPtr ptr)
1040     {
1041         var tmp = (ModelChildrenEvent.NativeStruct)Marshal.PtrToStructure(ptr, typeof(ModelChildrenEvent.NativeStruct));
1042         return tmp;
1043     }
1044
1045     #pragma warning disable CS1591
1046
1047     ///<summary>Internal wrapper for struct ModelChildrenEvent.</summary>
1048     [StructLayout(LayoutKind.Sequential)]
1049     public struct NativeStruct
1050     {
1051
1052         public uint Index;
1053         ///<summary>Internal wrapper for field Child</summary>
1054         public System.IntPtr Child;
1055         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1056         public static implicit operator ModelChildrenEvent.NativeStruct(ModelChildrenEvent _external_struct)
1057         {
1058             var _internal_struct = new ModelChildrenEvent.NativeStruct();
1059             _internal_struct.Index = _external_struct.Index;
1060             _internal_struct.Child = _external_struct.Child?.NativeHandle ?? System.IntPtr.Zero;
1061             return _internal_struct;
1062         }
1063
1064         ///<summary>Implicit conversion to the managed representation.</summary>
1065         public static implicit operator ModelChildrenEvent(ModelChildrenEvent.NativeStruct _internal_struct)
1066         {
1067             var _external_struct = new ModelChildrenEvent();
1068             _external_struct.Index = _internal_struct.Index;
1069
1070             _external_struct.Child = (Efl.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Child);
1071             return _external_struct;
1072         }
1073
1074     }
1075
1076     #pragma warning restore CS1591
1077
1078 }
1079
1080 }
1081