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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  12 [Efl.LoopModel.NativeMethods]
  13 [Efl.Eo.BindingEntity]
  14 public abstract class LoopModel : Efl.LoopConsumer, Efl.IModel
  15 {
  16     /// <summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(LoopModel))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  33         efl_loop_model_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="LoopModel"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     public LoopModel(Efl.Object parent= null
  37             ) : base(efl_loop_model_class_get(), parent)
  38     {
  39         FinishInstantiation();
  40     }
  41
  42     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  43     /// Do not call this constructor directly.</summary>
  44     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  45     protected LoopModel(ConstructingHandle ch) : base(ch)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="LoopModel"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="wh">The native pointer to be wrapped.</param>
  52     protected LoopModel(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  53     {
  54     }
  55
  56     [Efl.Eo.PrivateNativeClass]
  57     private class LoopModelRealized : LoopModel
  58     {
  59         private LoopModelRealized(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60         {
  61         }
  62     }
  63     /// <summary>Initializes a new instance of the <see cref="LoopModel"/> class.
  64     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  65     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  66     /// <param name="parent">The Efl.Object parent of this instance.</param>
  67     protected LoopModel(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Event dispatched when properties list is available.</summary>
  72     /// <value><see cref="Efl.IModelPropertiesChangedEvt_Args"/></value>
  73     public event EventHandler<Efl.IModelPropertiesChangedEvt_Args> PropertiesChangedEvt
  74     {
  75         add
  76         {
  77             lock (eflBindingEventLock)
  78             {
  79                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  80                 {
  81                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  82                     if (obj != null)
  83                     {
  84                         Efl.IModelPropertiesChangedEvt_Args args = new Efl.IModelPropertiesChangedEvt_Args();
  85                         args.arg =  evt.Info;
  86                         try
  87                         {
  88                             value?.Invoke(obj, args);
  89                         }
  90                         catch (Exception e)
  91                         {
  92                             Eina.Log.Error(e.ToString());
  93                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  94                         }
  95                     }
  96                 };
  97
  98                 string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
  99                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 100             }
 101         }
 102
 103         remove
 104         {
 105             lock (eflBindingEventLock)
 106             {
 107                 string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
 108                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 109             }
 110         }
 111     }
 112     /// <summary>Method to raise event PropertiesChangedEvt.</summary>
 113     public void OnPropertiesChangedEvt(Efl.IModelPropertiesChangedEvt_Args e)
 114     {
 115         var key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
 116         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 117         if (desc == IntPtr.Zero)
 118         {
 119             Eina.Log.Error($"Failed to get native event {key}");
 120             return;
 121         }
 122
 123         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 124         try
 125         {
 126             Marshal.StructureToPtr(e.arg, info, false);
 127             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 128         }
 129         finally
 130         {
 131             Marshal.FreeHGlobal(info);
 132         }
 133     }
 134     /// <summary>Event dispatched when new child is added.</summary>
 135     /// <value><see cref="Efl.IModelChildAddedEvt_Args"/></value>
 136     public event EventHandler<Efl.IModelChildAddedEvt_Args> ChildAddedEvt
 137     {
 138         add
 139         {
 140             lock (eflBindingEventLock)
 141             {
 142                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 143                 {
 144                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 145                     if (obj != null)
 146                     {
 147                         Efl.IModelChildAddedEvt_Args args = new Efl.IModelChildAddedEvt_Args();
 148                         args.arg =  evt.Info;
 149                         try
 150                         {
 151                             value?.Invoke(obj, args);
 152                         }
 153                         catch (Exception e)
 154                         {
 155                             Eina.Log.Error(e.ToString());
 156                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 157                         }
 158                     }
 159                 };
 160
 161                 string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 162                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 163             }
 164         }
 165
 166         remove
 167         {
 168             lock (eflBindingEventLock)
 169             {
 170                 string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 171                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 172             }
 173         }
 174     }
 175     /// <summary>Method to raise event ChildAddedEvt.</summary>
 176     public void OnChildAddedEvt(Efl.IModelChildAddedEvt_Args e)
 177     {
 178         var key = "_EFL_MODEL_EVENT_CHILD_ADDED";
 179         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 180         if (desc == IntPtr.Zero)
 181         {
 182             Eina.Log.Error($"Failed to get native event {key}");
 183             return;
 184         }
 185
 186         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 187         try
 188         {
 189             Marshal.StructureToPtr(e.arg, info, false);
 190             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 191         }
 192         finally
 193         {
 194             Marshal.FreeHGlobal(info);
 195         }
 196     }
 197     /// <summary>Event dispatched when child is removed.</summary>
 198     /// <value><see cref="Efl.IModelChildRemovedEvt_Args"/></value>
 199     public event EventHandler<Efl.IModelChildRemovedEvt_Args> ChildRemovedEvt
 200     {
 201         add
 202         {
 203             lock (eflBindingEventLock)
 204             {
 205                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 206                 {
 207                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 208                     if (obj != null)
 209                     {
 210                         Efl.IModelChildRemovedEvt_Args args = new Efl.IModelChildRemovedEvt_Args();
 211                         args.arg =  evt.Info;
 212                         try
 213                         {
 214                             value?.Invoke(obj, args);
 215                         }
 216                         catch (Exception e)
 217                         {
 218                             Eina.Log.Error(e.ToString());
 219                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 220                         }
 221                     }
 222                 };
 223
 224                 string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 225                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 226             }
 227         }
 228
 229         remove
 230         {
 231             lock (eflBindingEventLock)
 232             {
 233                 string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 234                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 235             }
 236         }
 237     }
 238     /// <summary>Method to raise event ChildRemovedEvt.</summary>
 239     public void OnChildRemovedEvt(Efl.IModelChildRemovedEvt_Args e)
 240     {
 241         var key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
 242         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 243         if (desc == IntPtr.Zero)
 244         {
 245             Eina.Log.Error($"Failed to get native event {key}");
 246             return;
 247         }
 248
 249         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 250         try
 251         {
 252             Marshal.StructureToPtr(e.arg, info, false);
 253             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 254         }
 255         finally
 256         {
 257             Marshal.FreeHGlobal(info);
 258         }
 259     }
 260     /// <summary>Event dispatched when children count is finished.</summary>
 261     public event EventHandler ChildrenCountChangedEvt
 262     {
 263         add
 264         {
 265             lock (eflBindingEventLock)
 266             {
 267                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 268                 {
 269                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 270                     if (obj != null)
 271                     {
 272                         EventArgs args = EventArgs.Empty;
 273                         try
 274                         {
 275                             value?.Invoke(obj, args);
 276                         }
 277                         catch (Exception e)
 278                         {
 279                             Eina.Log.Error(e.ToString());
 280                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 281                         }
 282                     }
 283                 };
 284
 285                 string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 286                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 287             }
 288         }
 289
 290         remove
 291         {
 292             lock (eflBindingEventLock)
 293             {
 294                 string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 295                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 296             }
 297         }
 298     }
 299     /// <summary>Method to raise event ChildrenCountChangedEvt.</summary>
 300     public void OnChildrenCountChangedEvt(EventArgs e)
 301     {
 302         var key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
 303         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 304         if (desc == IntPtr.Zero)
 305         {
 306             Eina.Log.Error($"Failed to get native event {key}");
 307             return;
 308         }
 309
 310         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 311     }
 312     /// <summary>To be called when a Child model is created by <see cref="Efl.IModel.GetChildrenSlice"/> by the one creating the child object.
 313     /// This function is used to properly define the lifecycle of the new Child Model object and make sure that once it has 0 ref except its parent Model, it will be destroyed. This function should only be called once per child. It is useful for <see cref="Efl.IModel"/> who have a lot of children and shouldn&apos;t keep more than what is used in memory.</summary>
 314     virtual public void VolatileMake() {
 315          Efl.LoopModel.NativeMethods.efl_loop_model_volatile_make_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 316         Eina.Error.RaiseIfUnhandledException();
 317          }
 318     /// <summary>Get properties from model.
 319     /// 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.
 320     ///
 321     /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 322     /// <returns>Array of current properties</returns>
 323     virtual public Eina.Iterator<System.String> GetProperties() {
 324          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_properties_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 325         Eina.Error.RaiseIfUnhandledException();
 326         return new Eina.Iterator<System.String>(_ret_var, true);
 327  }
 328     /// <summary>Retrieve the value of a given property name.
 329     /// 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.
 330     ///
 331     /// See <see cref="Efl.IModel.GetProperties"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
 332     /// <param name="property">Property name</param>
 333     /// <returns>Property value</returns>
 334     virtual public Eina.Value GetProperty(System.String property) {
 335                                  var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),property);
 336         Eina.Error.RaiseIfUnhandledException();
 337                         return _ret_var;
 338  }
 339     /// <summary>Set a property value of a given property name.
 340     /// 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.
 341     ///
 342     /// 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
 343     ///
 344     /// See <see cref="Efl.IModel.GetProperty"/>, <see cref="Efl.IModel.PropertiesChangedEvt"/></summary>
 345     /// <param name="property">Property name</param>
 346     /// <param name="value">Property value</param>
 347     /// <returns>Return an error in case the property could not be set, the value that was set otherwise.</returns>
 348     virtual public  Eina.Future SetProperty(System.String property, Eina.Value value) {
 349                                                          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),property, value);
 350         Eina.Error.RaiseIfUnhandledException();
 351                                         return _ret_var;
 352  }
 353     /// <summary>Get children count.
 354     /// 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.
 355     ///
 356     /// See also <see cref="Efl.IModel.GetChildrenSlice"/>.</summary>
 357     /// <returns>Current known children count</returns>
 358     virtual public uint GetChildrenCount() {
 359          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_children_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 360         Eina.Error.RaiseIfUnhandledException();
 361         return _ret_var;
 362  }
 363     /// <summary>Get a future value when it changes to something that is not error:EAGAIN
 364     /// <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.
 365     ///
 366     /// The future can also be canceled if the model itself gets destroyed.</summary>
 367     /// <param name="property">Property name.</param>
 368     /// <returns>Future to be resolved when the property changes to anything other than error:EAGAIN</returns>
 369     virtual public  Eina.Future GetPropertyReady(System.String property) {
 370                                  var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_property_ready_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),property);
 371         Eina.Error.RaiseIfUnhandledException();
 372                         return _ret_var;
 373  }
 374     /// <summary>Get children slice OR full range.
 375     /// <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.
 376     ///
 377     /// 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:
 378     ///
 379     /// child 0  [no] child 1  [no] child 2  [no] child 3  [yes] child 4  [yes] child 5  [yes] child 6  [yes] child 7  [no]
 380     ///
 381     /// 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.
 382     ///
 383     /// See <see cref="Efl.IModel.GetChildrenCount"/>
 384     ///
 385     /// 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>
 386     /// <param name="start">Range begin - start from here.</param>
 387     /// <param name="count">Range size. If count is 0, start is ignored.</param>
 388     /// <returns>Array of children</returns>
 389     virtual public  Eina.Future GetChildrenSlice(uint start, uint count) {
 390                                                          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_children_slice_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),start, count);
 391         Eina.Error.RaiseIfUnhandledException();
 392                                         return _ret_var;
 393  }
 394     /// <summary>Add a new child.
 395     /// 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>
 396     /// <returns>Child object</returns>
 397     virtual public Efl.Object AddChild() {
 398          var _ret_var = Efl.IModelConcrete.NativeMethods.efl_model_child_add_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 399         Eina.Error.RaiseIfUnhandledException();
 400         return _ret_var;
 401  }
 402     /// <summary>Remove a child.
 403     /// 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>
 404     /// <param name="child">Child to be removed</param>
 405     virtual public void DelChild(Efl.Object child) {
 406                                  Efl.IModelConcrete.NativeMethods.efl_model_child_del_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),child);
 407         Eina.Error.RaiseIfUnhandledException();
 408                          }
 409     /// <summary>Async wrapper for <see cref="SetProperty" />.</summary>
 410     /// <param name="property">Property name</param>
 411     /// <param name="value">Property value</param>
 412     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 413     /// <returns>An async task wrapping the result of the operation.</returns>
 414     public System.Threading.Tasks.Task<Eina.Value> SetPropertyAsync(System.String property,Eina.Value value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 415     {
 416         Eina.Future future = SetProperty( property, value);
 417         return Efl.Eo.Globals.WrapAsync(future, token);
 418     }
 419
 420     /// <summary>Async wrapper for <see cref="GetPropertyReady" />.</summary>
 421     /// <param name="property">Property name.</param>
 422     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 423     /// <returns>An async task wrapping the result of the operation.</returns>
 424     public System.Threading.Tasks.Task<Eina.Value> GetPropertyReadyAsync(System.String property, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 425     {
 426         Eina.Future future = GetPropertyReady( property);
 427         return Efl.Eo.Globals.WrapAsync(future, token);
 428     }
 429
 430     /// <summary>Async wrapper for <see cref="GetChildrenSlice" />.</summary>
 431     /// <param name="start">Range begin - start from here.</param>
 432     /// <param name="count">Range size. If count is 0, start is ignored.</param>
 433     /// <param name="token">Token to notify the async operation of external request to cancel.</param>
 434     /// <returns>An async task wrapping the result of the operation.</returns>
 435     public System.Threading.Tasks.Task<Eina.Value> GetChildrenSliceAsync(uint start,uint count, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
 436     {
 437         Eina.Future future = GetChildrenSlice( start, count);
 438         return Efl.Eo.Globals.WrapAsync(future, token);
 439     }
 440
 441     /// <summary>Get properties from model.
 442     /// 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.
 443     ///
 444     /// See also <see cref="Efl.IModel.PropertiesChangedEvt"/>.</summary>
 445     /// <value>Array of current properties</value>
 446     public Eina.Iterator<System.String> Properties {
 447         get { return GetProperties(); }
 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     /// <value>Current known children count</value>
 454     public uint ChildrenCount {
 455         get { return GetChildrenCount(); }
 456     }
 457     private static IntPtr GetEflClassStatic()
 458     {
 459         return Efl.LoopModel.efl_loop_model_class_get();
 460     }
 461     /// <summary>Wrapper for native methods and virtual method delegates.
 462     /// For internal use by generated code only.</summary>
 463     public new class NativeMethods : Efl.LoopConsumer.NativeMethods
 464     {
 465         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 466         /// <summary>Gets the list of Eo operations to override.</summary>
 467         /// <returns>The list of Eo operations to be overload.</returns>
 468         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 469         {
 470             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 471             var methods = Efl.Eo.Globals.GetUserMethods(type);
 472
 473             if (efl_loop_model_volatile_make_static_delegate == null)
 474             {
 475                 efl_loop_model_volatile_make_static_delegate = new efl_loop_model_volatile_make_delegate(volatile_make);
 476             }
 477
 478             if (methods.FirstOrDefault(m => m.Name == "VolatileMake") != null)
 479             {
 480                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_loop_model_volatile_make"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_model_volatile_make_static_delegate) });
 481             }
 482
 483             if (efl_model_properties_get_static_delegate == null)
 484             {
 485                 efl_model_properties_get_static_delegate = new efl_model_properties_get_delegate(properties_get);
 486             }
 487
 488             if (methods.FirstOrDefault(m => m.Name == "GetProperties") != null)
 489             {
 490                 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) });
 491             }
 492
 493             if (efl_model_property_get_static_delegate == null)
 494             {
 495                 efl_model_property_get_static_delegate = new efl_model_property_get_delegate(property_get);
 496             }
 497
 498             if (methods.FirstOrDefault(m => m.Name == "GetProperty") != null)
 499             {
 500                 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) });
 501             }
 502
 503             if (efl_model_property_set_static_delegate == null)
 504             {
 505                 efl_model_property_set_static_delegate = new efl_model_property_set_delegate(property_set);
 506             }
 507
 508             if (methods.FirstOrDefault(m => m.Name == "SetProperty") != null)
 509             {
 510                 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) });
 511             }
 512
 513             if (efl_model_children_count_get_static_delegate == null)
 514             {
 515                 efl_model_children_count_get_static_delegate = new efl_model_children_count_get_delegate(children_count_get);
 516             }
 517
 518             if (methods.FirstOrDefault(m => m.Name == "GetChildrenCount") != null)
 519             {
 520                 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) });
 521             }
 522
 523             if (efl_model_property_ready_get_static_delegate == null)
 524             {
 525                 efl_model_property_ready_get_static_delegate = new efl_model_property_ready_get_delegate(property_ready_get);
 526             }
 527
 528             if (methods.FirstOrDefault(m => m.Name == "GetPropertyReady") != null)
 529             {
 530                 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) });
 531             }
 532
 533             if (efl_model_children_slice_get_static_delegate == null)
 534             {
 535                 efl_model_children_slice_get_static_delegate = new efl_model_children_slice_get_delegate(children_slice_get);
 536             }
 537
 538             if (methods.FirstOrDefault(m => m.Name == "GetChildrenSlice") != null)
 539             {
 540                 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) });
 541             }
 542
 543             if (efl_model_child_add_static_delegate == null)
 544             {
 545                 efl_model_child_add_static_delegate = new efl_model_child_add_delegate(child_add);
 546             }
 547
 548             if (methods.FirstOrDefault(m => m.Name == "AddChild") != null)
 549             {
 550                 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) });
 551             }
 552
 553             if (efl_model_child_del_static_delegate == null)
 554             {
 555                 efl_model_child_del_static_delegate = new efl_model_child_del_delegate(child_del);
 556             }
 557
 558             if (methods.FirstOrDefault(m => m.Name == "DelChild") != null)
 559             {
 560                 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) });
 561             }
 562
 563             descs.AddRange(base.GetEoOps(type));
 564             return descs;
 565         }
 566         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 567         /// <returns>The native class pointer.</returns>
 568         public override IntPtr GetEflClass()
 569         {
 570             return Efl.LoopModel.efl_loop_model_class_get();
 571         }
 572
 573         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 574
 575
 576         private delegate void efl_loop_model_volatile_make_delegate(System.IntPtr obj, System.IntPtr pd);
 577
 578
 579         public delegate void efl_loop_model_volatile_make_api_delegate(System.IntPtr obj);
 580
 581         public static Efl.Eo.FunctionWrapper<efl_loop_model_volatile_make_api_delegate> efl_loop_model_volatile_make_ptr = new Efl.Eo.FunctionWrapper<efl_loop_model_volatile_make_api_delegate>(Module, "efl_loop_model_volatile_make");
 582
 583         private static void volatile_make(System.IntPtr obj, System.IntPtr pd)
 584         {
 585             Eina.Log.Debug("function efl_loop_model_volatile_make was called");
 586             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 587             if (ws != null)
 588             {
 589
 590                 try
 591                 {
 592                     ((LoopModel)ws.Target).VolatileMake();
 593                 }
 594                 catch (Exception e)
 595                 {
 596                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 597                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598                 }
 599
 600
 601             }
 602             else
 603             {
 604                 efl_loop_model_volatile_make_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 605             }
 606         }
 607
 608         private static efl_loop_model_volatile_make_delegate efl_loop_model_volatile_make_static_delegate;
 609
 610
 611         private delegate System.IntPtr efl_model_properties_get_delegate(System.IntPtr obj, System.IntPtr pd);
 612
 613
 614         public delegate System.IntPtr efl_model_properties_get_api_delegate(System.IntPtr obj);
 615
 616         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");
 617
 618         private static System.IntPtr properties_get(System.IntPtr obj, System.IntPtr pd)
 619         {
 620             Eina.Log.Debug("function efl_model_properties_get was called");
 621             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 622             if (ws != null)
 623             {
 624             Eina.Iterator<System.String> _ret_var = default(Eina.Iterator<System.String>);
 625                 try
 626                 {
 627                     _ret_var = ((LoopModel)ws.Target).GetProperties();
 628                 }
 629                 catch (Exception e)
 630                 {
 631                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 632                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 633                 }
 634
 635         _ret_var.Own = false; return _ret_var.Handle;
 636
 637             }
 638             else
 639             {
 640                 return efl_model_properties_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 641             }
 642         }
 643
 644         private static efl_model_properties_get_delegate efl_model_properties_get_static_delegate;
 645
 646         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]
 647         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);
 648
 649         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]
 650         public delegate Eina.Value efl_model_property_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String property);
 651
 652         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");
 653
 654         private static Eina.Value property_get(System.IntPtr obj, System.IntPtr pd, System.String property)
 655         {
 656             Eina.Log.Debug("function efl_model_property_get was called");
 657             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 658             if (ws != null)
 659             {
 660                                     Eina.Value _ret_var = default(Eina.Value);
 661                 try
 662                 {
 663                     _ret_var = ((LoopModel)ws.Target).GetProperty(property);
 664                 }
 665                 catch (Exception e)
 666                 {
 667                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 668                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 669                 }
 670
 671                         return _ret_var;
 672
 673             }
 674             else
 675             {
 676                 return efl_model_property_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property);
 677             }
 678         }
 679
 680         private static efl_model_property_get_delegate efl_model_property_get_static_delegate;
 681
 682         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 683         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);
 684
 685         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 686         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);
 687
 688         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");
 689
 690         private static  Eina.Future property_set(System.IntPtr obj, System.IntPtr pd, System.String property, Eina.Value value)
 691         {
 692             Eina.Log.Debug("function efl_model_property_set was called");
 693             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 694             if (ws != null)
 695             {
 696                                                              Eina.Future _ret_var = default( Eina.Future);
 697                 try
 698                 {
 699                     _ret_var = ((LoopModel)ws.Target).SetProperty(property, value);
 700                 }
 701                 catch (Exception e)
 702                 {
 703                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 704                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 705                 }
 706
 707                                         return _ret_var;
 708
 709             }
 710             else
 711             {
 712                 return efl_model_property_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property, value);
 713             }
 714         }
 715
 716         private static efl_model_property_set_delegate efl_model_property_set_static_delegate;
 717
 718
 719         private delegate uint efl_model_children_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 720
 721
 722         public delegate uint efl_model_children_count_get_api_delegate(System.IntPtr obj);
 723
 724         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");
 725
 726         private static uint children_count_get(System.IntPtr obj, System.IntPtr pd)
 727         {
 728             Eina.Log.Debug("function efl_model_children_count_get was called");
 729             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 730             if (ws != null)
 731             {
 732             uint _ret_var = default(uint);
 733                 try
 734                 {
 735                     _ret_var = ((LoopModel)ws.Target).GetChildrenCount();
 736                 }
 737                 catch (Exception e)
 738                 {
 739                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 740                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 741                 }
 742
 743         return _ret_var;
 744
 745             }
 746             else
 747             {
 748                 return efl_model_children_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 749             }
 750         }
 751
 752         private static efl_model_children_count_get_delegate efl_model_children_count_get_static_delegate;
 753
 754         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 755         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);
 756
 757         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 758         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);
 759
 760         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");
 761
 762         private static  Eina.Future property_ready_get(System.IntPtr obj, System.IntPtr pd, System.String property)
 763         {
 764             Eina.Log.Debug("function efl_model_property_ready_get was called");
 765             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 766             if (ws != null)
 767             {
 768                                      Eina.Future _ret_var = default( Eina.Future);
 769                 try
 770                 {
 771                     _ret_var = ((LoopModel)ws.Target).GetPropertyReady(property);
 772                 }
 773                 catch (Exception e)
 774                 {
 775                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 776                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 777                 }
 778
 779                         return _ret_var;
 780
 781             }
 782             else
 783             {
 784                 return efl_model_property_ready_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), property);
 785             }
 786         }
 787
 788         private static efl_model_property_ready_get_delegate efl_model_property_ready_get_static_delegate;
 789
 790         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 791         private delegate  Eina.Future efl_model_children_slice_get_delegate(System.IntPtr obj, System.IntPtr pd,  uint start,  uint count);
 792
 793         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
 794         public delegate  Eina.Future efl_model_children_slice_get_api_delegate(System.IntPtr obj,  uint start,  uint count);
 795
 796         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");
 797
 798         private static  Eina.Future children_slice_get(System.IntPtr obj, System.IntPtr pd, uint start, uint count)
 799         {
 800             Eina.Log.Debug("function efl_model_children_slice_get was called");
 801             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 802             if (ws != null)
 803             {
 804                                                              Eina.Future _ret_var = default( Eina.Future);
 805                 try
 806                 {
 807                     _ret_var = ((LoopModel)ws.Target).GetChildrenSlice(start, count);
 808                 }
 809                 catch (Exception e)
 810                 {
 811                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 812                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 813                 }
 814
 815                                         return _ret_var;
 816
 817             }
 818             else
 819             {
 820                 return efl_model_children_slice_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, count);
 821             }
 822         }
 823
 824         private static efl_model_children_slice_get_delegate efl_model_children_slice_get_static_delegate;
 825
 826         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 827         private delegate Efl.Object efl_model_child_add_delegate(System.IntPtr obj, System.IntPtr pd);
 828
 829         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 830         public delegate Efl.Object efl_model_child_add_api_delegate(System.IntPtr obj);
 831
 832         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");
 833
 834         private static Efl.Object child_add(System.IntPtr obj, System.IntPtr pd)
 835         {
 836             Eina.Log.Debug("function efl_model_child_add was called");
 837             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 838             if (ws != null)
 839             {
 840             Efl.Object _ret_var = default(Efl.Object);
 841                 try
 842                 {
 843                     _ret_var = ((LoopModel)ws.Target).AddChild();
 844                 }
 845                 catch (Exception e)
 846                 {
 847                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 848                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 849                 }
 850
 851         return _ret_var;
 852
 853             }
 854             else
 855             {
 856                 return efl_model_child_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 857             }
 858         }
 859
 860         private static efl_model_child_add_delegate efl_model_child_add_static_delegate;
 861
 862
 863         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);
 864
 865
 866         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);
 867
 868         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");
 869
 870         private static void child_del(System.IntPtr obj, System.IntPtr pd, Efl.Object child)
 871         {
 872             Eina.Log.Debug("function efl_model_child_del was called");
 873             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 874             if (ws != null)
 875             {
 876
 877                 try
 878                 {
 879                     ((LoopModel)ws.Target).DelChild(child);
 880                 }
 881                 catch (Exception e)
 882                 {
 883                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 884                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 885                 }
 886
 887
 888             }
 889             else
 890             {
 891                 efl_model_child_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
 892             }
 893         }
 894
 895         private static efl_model_child_del_delegate efl_model_child_del_static_delegate;
 896
 897         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 898
 899 }
 900 }
 901 }
 902
 903 #if EFL_BETA
 904 #pragma warning disable CS1591
 905 public static class EflLoopModel_ExtensionMethods {
 906
 907
 908
 909 }
 910 #pragma warning restore CS1591
 911 #endif