internals/src/EflSharp/EflSharp/efl/efl_object.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>Callback priority. Range is -32k - 32k. The lower the number, the higher the priority.
  11 /// This is used to insert an event handler relative to the existing stack of sorted event handlers according to that priority. All event handlers always have a priority. If not specified <see cref="Efl.Constants.CallbackPriorityDefault"/> is to be assumed.
  12 ///
  13 /// See <see cref="Efl.Constants.CallbackPriorityBefore"/> <see cref="Efl.Constants.CallbackPriorityDefault"/>  <see cref="Efl.Constants.CallbackPriorityAfter"/>
  14 /// (Since EFL 1.22)</summary>
  15 public struct CallbackPriority
  16 {
  17     private short payload;
  18
  19     /// <summary>Converts an instance of short to this struct.</summary>
  20     /// <param name="value">The value to be converted.</param>
  21     /// <returns>A struct with the given value.</returns>
  22     public static implicit operator CallbackPriority(short value)
  23     {
  24         return new CallbackPriority{payload=value};
  25     }
  26
  27     /// <summary>Converts an instance of this struct to short.</summary>
  28     /// <param name="value">The value to be converted packed in this struct.</param>
  29     /// <returns>The actual value the alias is wrapping.</returns>
  30     public static implicit operator short(CallbackPriority value)
  31     {
  32         return value.payload;
  33     }
  34
  35 }
  36
  37 }
  38
  39 namespace Efl {
  40
  41 public partial class Constants
  42 {
  43     /// <summary>Slightly more prioritized than default.</summary>
  44     public static readonly Efl.CallbackPriority CallbackPriorityBefore = -100;
  45 }
  46 }
  47
  48 namespace Efl {
  49
  50 public partial class Constants
  51 {
  52     /// <summary>Default priority.</summary>
  53     public static readonly Efl.CallbackPriority CallbackPriorityDefault = 0;
  54 }
  55 }
  56
  57 namespace Efl {
  58
  59 public partial class Constants
  60 {
  61     /// <summary>Slightly less prioritized than default.</summary>
  62     public static readonly Efl.CallbackPriority CallbackPriorityAfter = 100;
  63 }
  64 }
  65
  66 namespace Efl {
  67
  68 /// <summary>Abstract EFL object class.
  69 /// All EFL objects inherit from this class, which provides basic functionality like naming, debugging, hierarchy traversal, event emission and life cycle management.
  70 ///
  71 /// Life Cycle Objects are created with efl_add() and mostly disposed of with efl_del(). As an optimization, efl_add() accepts a list of initialization functions which the programmer can use to further customize the object before it is fully constructed. Also, objects can have a parent which will keep them alive as long as the parent is alive, so the programmer does not need to keep track of references. (See the <see cref="Efl.Object.Parent"/> property for details). Due to the above characteristics, EFL objects undergo the following phases during their Life Cycle: - Construction: The Efl.Object.constructor method is called. Afterwards, any user-supplied initialization methods are called. - Finalization: The <see cref="Efl.Object.FinalizeAdd"/> method is called and <see cref="Efl.Object.GetFinalized"/> is set to <c>true</c> when it returns. Object is usable at this point. - Invalidation: The object has lost its parent. The <see cref="Efl.Object.Invalidate"/> method is called so all the object&apos;s relationships can be terminated. <see cref="Efl.Object.GetInvalidated"/> is set to <c>true</c>. - Destruction: The object has no parent and it can be destroyed. The <see cref="Efl.Object.Destructor"/> method is called, use it to return any resources the object might have gathered during its life.
  72 /// (Since EFL 1.22)</summary>
  73 [Efl.Object.NativeMethods]
  74 [Efl.Eo.BindingEntity]
  75 public abstract class Object : Efl.Eo.EoWrapper
  76 {
  77     ///<summary>Pointer to the native class description.</summary>
  78     public override System.IntPtr NativeClass
  79     {
  80         get
  81         {
  82             if (((object)this).GetType() == typeof(Object))
  83             {
  84                 return GetEflClassStatic();
  85             }
  86             else
  87             {
  88                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  89             }
  90         }
  91     }
  92
  93     [System.Runtime.InteropServices.DllImport(efl.Libs.Eo)] internal static extern System.IntPtr
  94         efl_object_class_get();
  95     /// <summary>Initializes a new instance of the <see cref="Object"/> class.</summary>
  96     /// <param name="parent">Parent instance.</param>
  97     public Object(Efl.Object parent= null
  98             ) : base(efl_object_class_get(), parent)
  99     {
 100         FinishInstantiation();
 101     }
 102
 103     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 104     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 105     protected Object(ConstructingHandle ch) : base(ch)
 106     {
 107     }
 108
 109     /// <summary>Initializes a new instance of the <see cref="Object"/> class.
 110     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 111     /// <param name="wh">The native pointer to be wrapped.</param>
 112     protected Object(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 113     {
 114     }
 115
 116     [Efl.Eo.PrivateNativeClass]
 117     private class ObjectRealized : Object
 118     {
 119         private ObjectRealized(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 120         {
 121         }
 122     }
 123     /// <summary>Initializes a new instance of the <see cref="Object"/> class.
 124     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
 125     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
 126     /// <param name="parent">The Efl.Object parent of this instance.</param>
 127     protected Object(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
 128     {
 129     }
 130
 131     /// <summary>Object is being deleted. See <see cref="Efl.Object.Destructor"/>.
 132     /// (Since EFL 1.22)</summary>
 133     public event EventHandler DelEvt
 134     {
 135         add
 136         {
 137             lock (eflBindingEventLock)
 138             {
 139                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 140                 {
 141                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 142                     if (obj != null)
 143                     {
 144                         EventArgs args = EventArgs.Empty;
 145                         try
 146                         {
 147                             value?.Invoke(obj, args);
 148                         }
 149                         catch (Exception e)
 150                         {
 151                             Eina.Log.Error(e.ToString());
 152                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 153                         }
 154                     }
 155                 };
 156
 157                 string key = "_EFL_EVENT_DEL";
 158                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 159             }
 160         }
 161
 162         remove
 163         {
 164             lock (eflBindingEventLock)
 165             {
 166                 string key = "_EFL_EVENT_DEL";
 167                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 168             }
 169         }
 170     }
 171     ///<summary>Method to raise event DelEvt.</summary>
 172     public void OnDelEvt(EventArgs e)
 173     {
 174         var key = "_EFL_EVENT_DEL";
 175         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 176         if (desc == IntPtr.Zero)
 177         {
 178             Eina.Log.Error($"Failed to get native event {key}");
 179             return;
 180         }
 181
 182         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 183     }
 184     /// <summary>Object is being invalidated and losing its parent. See <see cref="Efl.Object.Invalidate"/>.
 185     /// (Since EFL 1.22)</summary>
 186     public event EventHandler InvalidateEvt
 187     {
 188         add
 189         {
 190             lock (eflBindingEventLock)
 191             {
 192                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 193                 {
 194                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 195                     if (obj != null)
 196                     {
 197                         EventArgs args = EventArgs.Empty;
 198                         try
 199                         {
 200                             value?.Invoke(obj, args);
 201                         }
 202                         catch (Exception e)
 203                         {
 204                             Eina.Log.Error(e.ToString());
 205                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 206                         }
 207                     }
 208                 };
 209
 210                 string key = "_EFL_EVENT_INVALIDATE";
 211                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 212             }
 213         }
 214
 215         remove
 216         {
 217             lock (eflBindingEventLock)
 218             {
 219                 string key = "_EFL_EVENT_INVALIDATE";
 220                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 221             }
 222         }
 223     }
 224     ///<summary>Method to raise event InvalidateEvt.</summary>
 225     public void OnInvalidateEvt(EventArgs e)
 226     {
 227         var key = "_EFL_EVENT_INVALIDATE";
 228         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 229         if (desc == IntPtr.Zero)
 230         {
 231             Eina.Log.Error($"Failed to get native event {key}");
 232             return;
 233         }
 234
 235         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 236     }
 237     /// <summary>Object has lost its last reference, only parent relationship is keeping it alive. Advanced usage.
 238     /// (Since EFL 1.22)</summary>
 239     public event EventHandler NorefEvt
 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                         EventArgs args = EventArgs.Empty;
 251                         try
 252                         {
 253                             value?.Invoke(obj, args);
 254                         }
 255                         catch (Exception e)
 256                         {
 257                             Eina.Log.Error(e.ToString());
 258                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 259                         }
 260                     }
 261                 };
 262
 263                 string key = "_EFL_EVENT_NOREF";
 264                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 265             }
 266         }
 267
 268         remove
 269         {
 270             lock (eflBindingEventLock)
 271             {
 272                 string key = "_EFL_EVENT_NOREF";
 273                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 274             }
 275         }
 276     }
 277     ///<summary>Method to raise event NorefEvt.</summary>
 278     public void OnNorefEvt(EventArgs e)
 279     {
 280         var key = "_EFL_EVENT_NOREF";
 281         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 282         if (desc == IntPtr.Zero)
 283         {
 284             Eina.Log.Error($"Failed to get native event {key}");
 285             return;
 286         }
 287
 288         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 289     }
 290     /// <summary>Object has lost a reference and only one is left. It has just one owner now. Triggered whenever the refcount goes from two to one.
 291     /// (Since EFL 1.22)</summary>
 292     public event EventHandler OwnershipUniqueEvt
 293     {
 294         add
 295         {
 296             lock (eflBindingEventLock)
 297             {
 298                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 299                 {
 300                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 301                     if (obj != null)
 302                     {
 303                         EventArgs args = EventArgs.Empty;
 304                         try
 305                         {
 306                             value?.Invoke(obj, args);
 307                         }
 308                         catch (Exception e)
 309                         {
 310                             Eina.Log.Error(e.ToString());
 311                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 312                         }
 313                     }
 314                 };
 315
 316                 string key = "_EFL_EVENT_OWNERSHIP_UNIQUE";
 317                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 318             }
 319         }
 320
 321         remove
 322         {
 323             lock (eflBindingEventLock)
 324             {
 325                 string key = "_EFL_EVENT_OWNERSHIP_UNIQUE";
 326                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 327             }
 328         }
 329     }
 330     ///<summary>Method to raise event OwnershipUniqueEvt.</summary>
 331     public void OnOwnershipUniqueEvt(EventArgs e)
 332     {
 333         var key = "_EFL_EVENT_OWNERSHIP_UNIQUE";
 334         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 335         if (desc == IntPtr.Zero)
 336         {
 337             Eina.Log.Error($"Failed to get native event {key}");
 338             return;
 339         }
 340
 341         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 342     }
 343     /// <summary>Object has acquired a second reference. It has multiple owners now. Triggered whenever increasing the refcount from one to two, it will not trigger by further increasing the refcount beyond two.
 344     /// (Since EFL 1.22)</summary>
 345     public event EventHandler OwnershipSharedEvt
 346     {
 347         add
 348         {
 349             lock (eflBindingEventLock)
 350             {
 351                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 352                 {
 353                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 354                     if (obj != null)
 355                     {
 356                         EventArgs args = EventArgs.Empty;
 357                         try
 358                         {
 359                             value?.Invoke(obj, args);
 360                         }
 361                         catch (Exception e)
 362                         {
 363                             Eina.Log.Error(e.ToString());
 364                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 365                         }
 366                     }
 367                 };
 368
 369                 string key = "_EFL_EVENT_OWNERSHIP_SHARED";
 370                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 371             }
 372         }
 373
 374         remove
 375         {
 376             lock (eflBindingEventLock)
 377             {
 378                 string key = "_EFL_EVENT_OWNERSHIP_SHARED";
 379                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 380             }
 381         }
 382     }
 383     ///<summary>Method to raise event OwnershipSharedEvt.</summary>
 384     public void OnOwnershipSharedEvt(EventArgs e)
 385     {
 386         var key = "_EFL_EVENT_OWNERSHIP_SHARED";
 387         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 388         if (desc == IntPtr.Zero)
 389         {
 390             Eina.Log.Error($"Failed to get native event {key}");
 391             return;
 392         }
 393
 394         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 395     }
 396     /// <summary>Object has been fully destroyed. It can not be used beyond this point. This event should only serve to clean up any reference you keep to the object.
 397     /// (Since EFL 1.22)</summary>
 398     public event EventHandler DestructEvt
 399     {
 400         add
 401         {
 402             lock (eflBindingEventLock)
 403             {
 404                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 405                 {
 406                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 407                     if (obj != null)
 408                     {
 409                         EventArgs args = EventArgs.Empty;
 410                         try
 411                         {
 412                             value?.Invoke(obj, args);
 413                         }
 414                         catch (Exception e)
 415                         {
 416                             Eina.Log.Error(e.ToString());
 417                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 418                         }
 419                     }
 420                 };
 421
 422                 string key = "_EFL_EVENT_DESTRUCT";
 423                 AddNativeEventHandler(efl.Libs.Eo, key, callerCb, value);
 424             }
 425         }
 426
 427         remove
 428         {
 429             lock (eflBindingEventLock)
 430             {
 431                 string key = "_EFL_EVENT_DESTRUCT";
 432                 RemoveNativeEventHandler(efl.Libs.Eo, key, value);
 433             }
 434         }
 435     }
 436     ///<summary>Method to raise event DestructEvt.</summary>
 437     public void OnDestructEvt(EventArgs e)
 438     {
 439         var key = "_EFL_EVENT_DESTRUCT";
 440         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Eo, key);
 441         if (desc == IntPtr.Zero)
 442         {
 443             Eina.Log.Error($"Failed to get native event {key}");
 444             return;
 445         }
 446
 447         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 448     }
 449     /// <summary>The parent of an object.
 450     /// Parents keep references to their children and will release these references when destroyed. In this way, objects can be assigned to a parent upon creation, tying their life cycle so the programmer does not need to worry about destroying the child object. In order to destroy an object before its parent, set the parent to <c>NULL</c> and use efl_unref(), or use efl_del() directly.
 451     ///
 452     /// The Eo parent is conceptually user set. That means that a parent should not be changed behind the scenes in an unexpected way.
 453     ///
 454     /// For example: If you have a widget which can swallow objects into an internal box, the parent of the swallowed objects should be the widget, not the internal box. The user is not even aware of the existence of the internal box.
 455     /// (Since EFL 1.22)</summary>
 456     /// <returns>The new parent.</returns>
 457     virtual public Efl.Object GetParent() {
 458          var _ret_var = Efl.Object.NativeMethods.efl_parent_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 459         Eina.Error.RaiseIfUnhandledException();
 460         return _ret_var;
 461  }
 462     /// <summary>The parent of an object.
 463     /// Parents keep references to their children and will release these references when destroyed. In this way, objects can be assigned to a parent upon creation, tying their life cycle so the programmer does not need to worry about destroying the child object. In order to destroy an object before its parent, set the parent to <c>NULL</c> and use efl_unref(), or use efl_del() directly.
 464     ///
 465     /// The Eo parent is conceptually user set. That means that a parent should not be changed behind the scenes in an unexpected way.
 466     ///
 467     /// For example: If you have a widget which can swallow objects into an internal box, the parent of the swallowed objects should be the widget, not the internal box. The user is not even aware of the existence of the internal box.
 468     /// (Since EFL 1.22)</summary>
 469     /// <param name="parent">The new parent.</param>
 470     virtual public void SetParent(Efl.Object parent) {
 471                                  Efl.Object.NativeMethods.efl_parent_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),parent);
 472         Eina.Error.RaiseIfUnhandledException();
 473                          }
 474     /// <summary>The name of the object.
 475     /// Every EFL object can have a name. Names may not contain the following characters: / ? * [ ] !  : Using any of these in a name will result in undefined behavior later on. An empty string is considered the same as a <c>NULL</c> string or no string for the name.
 476     /// (Since EFL 1.22)</summary>
 477     /// <returns>The name.</returns>
 478     virtual public System.String GetName() {
 479          var _ret_var = Efl.Object.NativeMethods.efl_name_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 480         Eina.Error.RaiseIfUnhandledException();
 481         return _ret_var;
 482  }
 483     /// <summary>The name of the object.
 484     /// Every EFL object can have a name. Names may not contain the following characters: / ? * [ ] !  : Using any of these in a name will result in undefined behavior later on. An empty string is considered the same as a <c>NULL</c> string or no string for the name.
 485     /// (Since EFL 1.22)</summary>
 486     /// <param name="name">The name.</param>
 487     virtual public void SetName(System.String name) {
 488                                  Efl.Object.NativeMethods.efl_name_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name);
 489         Eina.Error.RaiseIfUnhandledException();
 490                          }
 491     /// <summary>A human readable comment for the object.
 492     /// Every EFL object can have a comment. This is intended for developers and debugging. An empty string is considered the same as a <c>NULL</c> string or no string for the comment.
 493     /// (Since EFL 1.22)</summary>
 494     /// <returns>The comment.</returns>
 495     virtual public System.String GetComment() {
 496          var _ret_var = Efl.Object.NativeMethods.efl_comment_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 497         Eina.Error.RaiseIfUnhandledException();
 498         return _ret_var;
 499  }
 500     /// <summary>A human readable comment for the object.
 501     /// Every EFL object can have a comment. This is intended for developers and debugging. An empty string is considered the same as a <c>NULL</c> string or no string for the comment.
 502     /// (Since EFL 1.22)</summary>
 503     /// <param name="comment">The comment.</param>
 504     virtual public void SetComment(System.String comment) {
 505                                  Efl.Object.NativeMethods.efl_comment_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),comment);
 506         Eina.Error.RaiseIfUnhandledException();
 507                          }
 508     /// <summary>Return the global count of freeze events.
 509     /// This is the amount of calls to <see cref="Efl.Object.FreezeEventGlobal"/> minus the amount of calls to <see cref="Efl.Object.ThawEventGlobal"/>. EFL will not emit any event while this count is &gt; 0 (Except events marked <c>hot</c>).
 510     /// (Since EFL 1.22)</summary>
 511     /// <returns>The global event freeze count.</returns>
 512     public static int GetEventGlobalFreezeCount() {
 513          var _ret_var = Efl.Object.NativeMethods.efl_event_global_freeze_count_get_ptr.Value.Delegate();
 514         Eina.Error.RaiseIfUnhandledException();
 515         return _ret_var;
 516  }
 517     /// <summary>Return the count of freeze events for this object.
 518     /// This is the amount of calls to <see cref="Efl.Object.FreezeEvent"/> minus the amount of calls to <see cref="Efl.Object.ThawEvent"/>. This object will not emit any event while this count is &gt; 0 (Except events marked <c>hot</c>).
 519     /// (Since EFL 1.22)</summary>
 520     /// <returns>The event freeze count of this object.</returns>
 521     virtual public int GetEventFreezeCount() {
 522          var _ret_var = Efl.Object.NativeMethods.efl_event_freeze_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 523         Eina.Error.RaiseIfUnhandledException();
 524         return _ret_var;
 525  }
 526     /// <summary><c>true</c> if the object has been finalized, i.e. construction has finished. See the Life Cycle section in this class&apos; description.
 527     /// (Since EFL 1.22)</summary>
 528     /// <returns><c>true</c> if the object is finalized, <c>false</c> otherwise.</returns>
 529     virtual public bool GetFinalized() {
 530          var _ret_var = Efl.Object.NativeMethods.efl_finalized_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 531         Eina.Error.RaiseIfUnhandledException();
 532         return _ret_var;
 533  }
 534     /// <summary><c>true</c> if the object has been invalidated, i.e. it has no parent. See the Life Cycle section in this class&apos; description.
 535     /// (Since EFL 1.22)</summary>
 536     /// <returns><c>true</c> if the object is invalidated, <c>false</c> otherwise.</returns>
 537     virtual public bool GetInvalidated() {
 538          var _ret_var = Efl.Object.NativeMethods.efl_invalidated_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 539         Eina.Error.RaiseIfUnhandledException();
 540         return _ret_var;
 541  }
 542     /// <summary><c>true</c> if the object has started the invalidation phase, but has not finished it yet. Note: This might become <c>true</c> before <see cref="Efl.Object.Invalidate"/> is called. See the Life Cycle section in this class&apos; description.
 543     /// (Since EFL 1.22)</summary>
 544     /// <returns><c>true</c> if the object is invalidating, <c>false</c> otherwise.</returns>
 545     virtual public bool GetInvalidating() {
 546          var _ret_var = Efl.Object.NativeMethods.efl_invalidating_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 547         Eina.Error.RaiseIfUnhandledException();
 548         return _ret_var;
 549  }
 550     /// <summary>Allow an object to be deleted by unref even if it has a parent.
 551     /// This simply hides the error message warning that an object being destroyed still has a parent. This property is false by default.
 552     ///
 553     /// In a normal object use case, when ownership of an object is given to a caller, said ownership should be released with efl_unref(). If the object has a parent, this will print error messages, as efl_unref() is stealing the ref from the parent.
 554     ///
 555     /// Warning: Use this function very carefully, unless you&apos;re absolutely sure of what you are doing.
 556     /// (Since EFL 1.22)</summary>
 557     /// <returns>Whether to allow efl_unref() to zero even if <see cref="Efl.Object.Parent"/> is not <c>null</c>.</returns>
 558     virtual public bool GetAllowParentUnref() {
 559          var _ret_var = Efl.Object.NativeMethods.efl_allow_parent_unref_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 560         Eina.Error.RaiseIfUnhandledException();
 561         return _ret_var;
 562  }
 563     /// <summary>Allow an object to be deleted by unref even if it has a parent.
 564     /// This simply hides the error message warning that an object being destroyed still has a parent. This property is false by default.
 565     ///
 566     /// In a normal object use case, when ownership of an object is given to a caller, said ownership should be released with efl_unref(). If the object has a parent, this will print error messages, as efl_unref() is stealing the ref from the parent.
 567     ///
 568     /// Warning: Use this function very carefully, unless you&apos;re absolutely sure of what you are doing.
 569     /// (Since EFL 1.22)</summary>
 570     /// <param name="allow">Whether to allow efl_unref() to zero even if <see cref="Efl.Object.Parent"/> is not <c>null</c>.</param>
 571     virtual public void SetAllowParentUnref(bool allow) {
 572                                  Efl.Object.NativeMethods.efl_allow_parent_unref_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),allow);
 573         Eina.Error.RaiseIfUnhandledException();
 574                          }
 575     /// <summary>Build a read-only name for this object used for debugging.
 576     /// Multiple calls using efl_super() can be chained in order to build the entire debug name, from parent to child classes. In C the usual way to build the string is as follows:
 577     ///
 578     /// efl_debug_name_override(efl_super(obj, MY_CLASS), sb); eina_strbuf_append_printf(sb, &quot;new_information&quot;);
 579     ///
 580     /// Usually more debug information should be added to <c>sb</c> after calling the super function.
 581     /// (Since EFL 1.22)</summary>
 582     /// <param name="sb">A string buffer, must not be <c>null</c>.</param>
 583     virtual public void DebugNameOverride(Eina.Strbuf sb) {
 584                                  Efl.Object.NativeMethods.efl_debug_name_override_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),sb);
 585         Eina.Error.RaiseIfUnhandledException();
 586                          }
 587     /// <summary>Searches upwards in the object tree for a provider which knows the given class/interface.
 588     /// The object from the provider will then be returned. The base implementation calls the provider_find function on the object parent, and returns its result. If no parent is present NULL is returned. Each implementation has to support this function by overriding it and returning itself if the interface matches the parameter. If this is not done the class cannot be found up in the object tree.
 589     /// (Since EFL 1.22)</summary>
 590     /// <param name="klass">The class identifier to search for.</param>
 591     /// <returns>Object from the provider list.</returns>
 592     virtual public Efl.Object FindProvider(Type klass) {
 593                                  var _ret_var = Efl.Object.NativeMethods.efl_provider_find_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),klass);
 594         Eina.Error.RaiseIfUnhandledException();
 595                         return _ret_var;
 596  }
 597     /// <summary>Implement this method to provide deinitialization code for your object if you need it.
 598     /// Will be called once <see cref="Efl.Object.Invalidate"/> has returned. See the Life Cycle section in this class&apos; description.
 599     /// (Since EFL 1.22)</summary>
 600     virtual public void Destructor() {
 601          Efl.Object.NativeMethods.efl_destructor_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 602         Eina.Error.RaiseIfUnhandledException();
 603          }
 604     /// <summary>Implement this method to finish the initialization of your object after all (if any) user-provided configuration methods have been executed.
 605     /// Use this method to delay expensive operations until user configuration has finished, to avoid building the object in a &quot;default&quot; state in the constructor, just to have to throw it all away because a user configuration (a property being set, for example) requires a different state. This is the last call inside efl_add() and will set <see cref="Efl.Object.GetFinalized"/> to <c>true</c> once it returns. This is an optimization and implementing this method is optional if you already perform all your initialization in the Efl.Object.constructor method. See the Life Cycle section in this class&apos; description.
 606     /// (Since EFL 1.22)</summary>
 607     /// <returns>The new object. Return <c>NULL</c> to abort object creation.</returns>
 608     virtual public Efl.Object FinalizeAdd() {
 609          var _ret_var = Efl.Object.NativeMethods.efl_finalize_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 610         Eina.Error.RaiseIfUnhandledException();
 611         return _ret_var;
 612  }
 613     /// <summary>Implement this method to perform special actions when your object loses its parent, if you need to.
 614     /// It is called when the parent reference is lost or set to <c>NULL</c>. After this call returns, <see cref="Efl.Object.GetInvalidated"/> is set to <c>true</c>. This allows a simpler tear down of complex hierarchies, by performing object destruction in two steps, first all object relationships are broken and then the isolated objects are destroyed. Performing everything in the <see cref="Efl.Object.Destructor"/> can sometimes lead to deadlocks, but implementing this method is optional if this is not your case. When an object with a parent is destroyed, it first receives a call to <see cref="Efl.Object.Invalidate"/> and then to <see cref="Efl.Object.Destructor"/>. See the Life Cycle section in this class&apos; description.
 615     /// (Since EFL 1.22)</summary>
 616     virtual public void Invalidate() {
 617          Efl.Object.NativeMethods.efl_invalidate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 618         Eina.Error.RaiseIfUnhandledException();
 619          }
 620     /// <summary>Find a child object with the given name and return it.
 621     /// The search string can be a glob (shell style, using *). It can also specify class name in the format of &quot;class:name&quot; where &quot;:&quot; separates class and name. Both class and name can be globs. If the class is specified but the name is empty like &quot;class:&quot; then the search will match any object of that class.
 622     /// (Since EFL 1.22)</summary>
 623     /// <param name="search">The name search string.</param>
 624     /// <returns>The first object found.</returns>
 625     virtual public Efl.Object FindName(System.String search) {
 626                                  var _ret_var = Efl.Object.NativeMethods.efl_name_find_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),search);
 627         Eina.Error.RaiseIfUnhandledException();
 628                         return _ret_var;
 629  }
 630     /// <summary>Thaw events of object.
 631     /// Allows event callbacks to be called again for this object after a call to <see cref="Efl.Object.FreezeEvent"/>. The amount of thaws must match the amount of freezes for events to be re-enabled.
 632     /// (Since EFL 1.22)</summary>
 633     virtual public void ThawEvent() {
 634          Efl.Object.NativeMethods.efl_event_thaw_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 635         Eina.Error.RaiseIfUnhandledException();
 636          }
 637     /// <summary>Freeze events of this object.
 638     /// Prevents event callbacks from being called for this object. Enable events again using <see cref="Efl.Object.ThawEvent"/>. Events marked <c>hot</c> cannot be stopped.
 639     /// (Since EFL 1.22)</summary>
 640     virtual public void FreezeEvent() {
 641          Efl.Object.NativeMethods.efl_event_freeze_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 642         Eina.Error.RaiseIfUnhandledException();
 643          }
 644     /// <summary>Gobally thaw events for ALL EFL OBJECTS.
 645     /// Allows event callbacks to be called for all EFL objects after they have been disabled by <see cref="Efl.Object.FreezeEventGlobal"/>. The amount of thaws must match the amount of freezes for events to be re-enabled.
 646     /// (Since EFL 1.22)</summary>
 647     public static void ThawEventGlobal() {
 648          Efl.Object.NativeMethods.efl_event_global_thaw_ptr.Value.Delegate();
 649         Eina.Error.RaiseIfUnhandledException();
 650          }
 651     /// <summary>Globally freeze events for ALL EFL OBJECTS.
 652     /// Prevents event callbacks from being called for all EFL objects. Enable events again using <see cref="Efl.Object.ThawEventGlobal"/>. Events marked <c>hot</c> cannot be stopped.
 653     ///
 654     /// Note: USE WITH CAUTION.
 655     /// (Since EFL 1.22)</summary>
 656     public static void FreezeEventGlobal() {
 657          Efl.Object.NativeMethods.efl_event_global_freeze_ptr.Value.Delegate();
 658         Eina.Error.RaiseIfUnhandledException();
 659          }
 660     /// <summary>Stop the current callback call.
 661     /// This stops the current callback call. Any other callbacks for the current event will not be called. This is useful when you want to filter out events. Just add higher priority events and call this under certain conditions to block a certain event.
 662     /// (Since EFL 1.22)</summary>
 663     virtual public void EventCallbackStop() {
 664          Efl.Object.NativeMethods.efl_event_callback_stop_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 665         Eina.Error.RaiseIfUnhandledException();
 666          }
 667     /// <summary>Remove an event callback forwarder for a specified event and object.
 668     /// (Since EFL 1.22)</summary>
 669     /// <param name="desc">The description of the event to listen to</param>
 670     /// <param name="new_obj">The object to emit events from</param>
 671     virtual public void DelEventCallbackForwarder(Efl.EventDescription desc, Efl.Object new_obj) {
 672          var _in_desc = Eina.PrimitiveConversion.ManagedToPointerAlloc(desc);
 673                                                 Efl.Object.NativeMethods.efl_event_callback_forwarder_del_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_desc, new_obj);
 674         Eina.Error.RaiseIfUnhandledException();
 675                                          }
 676     /// <summary>Get an iterator on all childrens
 677     /// (Since EFL 1.22)</summary>
 678     /// <returns>Children iterator</returns>
 679     virtual public Eina.Iterator<Efl.Object> NewChildrenIterator() {
 680          var _ret_var = Efl.Object.NativeMethods.efl_children_iterator_new_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 681         Eina.Error.RaiseIfUnhandledException();
 682         return new Eina.Iterator<Efl.Object>(_ret_var, true);
 683  }
 684     /// <summary>Make an object a composite object of another.
 685     /// The class of comp_obj must be part of the extensions of the class of the parent. It isn&apos;t possible to attach more then 1 composite of the same class. This function also sets the parent of comp_obj to parent.
 686     ///
 687     /// See <see cref="Efl.Object.CompositeDetach"/>, <see cref="Efl.Object.IsCompositePart"/>.
 688     /// (Since EFL 1.22)</summary>
 689     /// <param name="comp_obj">the object that will be used to composite the parent.</param>
 690     /// <returns><c>true</c> if successful. <c>false</c> otherwise.</returns>
 691     virtual public bool AttachComposite(Efl.Object comp_obj) {
 692                                  var _ret_var = Efl.Object.NativeMethods.efl_composite_attach_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),comp_obj);
 693         Eina.Error.RaiseIfUnhandledException();
 694                         return _ret_var;
 695  }
 696     /// <summary>Detach a composite object from another object.
 697     /// This functions also sets the parent of comp_obj to <c>null</c>.
 698     ///
 699     /// See <see cref="Efl.Object.AttachComposite"/>, <see cref="Efl.Object.IsCompositePart"/>.
 700     /// (Since EFL 1.22)</summary>
 701     /// <param name="comp_obj">The object that will be removed from the parent.</param>
 702     /// <returns><c>true</c> if successful. <c>false</c> otherwise.</returns>
 703     virtual public bool CompositeDetach(Efl.Object comp_obj) {
 704                                  var _ret_var = Efl.Object.NativeMethods.efl_composite_detach_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),comp_obj);
 705         Eina.Error.RaiseIfUnhandledException();
 706                         return _ret_var;
 707  }
 708     /// <summary>Check if an object is part of a composite object.
 709     /// See <see cref="Efl.Object.AttachComposite"/>, <see cref="Efl.Object.IsCompositePart"/>.
 710     /// (Since EFL 1.22)</summary>
 711     /// <returns><c>true</c> if it is. <c>false</c> otherwise.</returns>
 712     virtual public bool IsCompositePart() {
 713          var _ret_var = Efl.Object.NativeMethods.efl_composite_part_is_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 714         Eina.Error.RaiseIfUnhandledException();
 715         return _ret_var;
 716  }
 717     /// <summary>The parent of an object.
 718     /// Parents keep references to their children and will release these references when destroyed. In this way, objects can be assigned to a parent upon creation, tying their life cycle so the programmer does not need to worry about destroying the child object. In order to destroy an object before its parent, set the parent to <c>NULL</c> and use efl_unref(), or use efl_del() directly.
 719     ///
 720     /// The Eo parent is conceptually user set. That means that a parent should not be changed behind the scenes in an unexpected way.
 721     ///
 722     /// For example: If you have a widget which can swallow objects into an internal box, the parent of the swallowed objects should be the widget, not the internal box. The user is not even aware of the existence of the internal box.
 723     /// (Since EFL 1.22)</summary>
 724     /// <value>The new parent.</value>
 725     public Efl.Object Parent {
 726         get { return GetParent(); }
 727         set { SetParent(value); }
 728     }
 729     /// <summary>The name of the object.
 730     /// Every EFL object can have a name. Names may not contain the following characters: / ? * [ ] !  : Using any of these in a name will result in undefined behavior later on. An empty string is considered the same as a <c>NULL</c> string or no string for the name.
 731     /// (Since EFL 1.22)</summary>
 732     /// <value>The name.</value>
 733     public System.String Name {
 734         get { return GetName(); }
 735         set { SetName(value); }
 736     }
 737     /// <summary>A human readable comment for the object.
 738     /// Every EFL object can have a comment. This is intended for developers and debugging. An empty string is considered the same as a <c>NULL</c> string or no string for the comment.
 739     /// (Since EFL 1.22)</summary>
 740     /// <value>The comment.</value>
 741     public System.String Comment {
 742         get { return GetComment(); }
 743         set { SetComment(value); }
 744     }
 745     /// <summary>Return the global count of freeze events.
 746     /// This is the amount of calls to <see cref="Efl.Object.FreezeEventGlobal"/> minus the amount of calls to <see cref="Efl.Object.ThawEventGlobal"/>. EFL will not emit any event while this count is &gt; 0 (Except events marked <c>hot</c>).
 747     /// (Since EFL 1.22)</summary>
 748     /// <value>The global event freeze count.</value>
 749     public static int EventGlobalFreezeCount {
 750         get { return GetEventGlobalFreezeCount(); }
 751     }
 752     /// <summary>Return the count of freeze events for this object.
 753     /// This is the amount of calls to <see cref="Efl.Object.FreezeEvent"/> minus the amount of calls to <see cref="Efl.Object.ThawEvent"/>. This object will not emit any event while this count is &gt; 0 (Except events marked <c>hot</c>).
 754     /// (Since EFL 1.22)</summary>
 755     /// <value>The event freeze count of this object.</value>
 756     public int EventFreezeCount {
 757         get { return GetEventFreezeCount(); }
 758     }
 759     /// <summary><c>true</c> if the object has been finalized, i.e. construction has finished. See the Life Cycle section in this class&apos; description.
 760     /// (Since EFL 1.22)</summary>
 761     /// <value><c>true</c> if the object is finalized, <c>false</c> otherwise.</value>
 762     public bool Finalized {
 763         get { return GetFinalized(); }
 764     }
 765     /// <summary><c>true</c> if the object has been invalidated, i.e. it has no parent. See the Life Cycle section in this class&apos; description.
 766     /// (Since EFL 1.22)</summary>
 767     /// <value><c>true</c> if the object is invalidated, <c>false</c> otherwise.</value>
 768     public bool Invalidated {
 769         get { return GetInvalidated(); }
 770     }
 771     /// <summary><c>true</c> if the object has started the invalidation phase, but has not finished it yet. Note: This might become <c>true</c> before <see cref="Efl.Object.Invalidate"/> is called. See the Life Cycle section in this class&apos; description.
 772     /// (Since EFL 1.22)</summary>
 773     /// <value><c>true</c> if the object is invalidating, <c>false</c> otherwise.</value>
 774     public bool Invalidating {
 775         get { return GetInvalidating(); }
 776     }
 777     /// <summary>Allow an object to be deleted by unref even if it has a parent.
 778     /// This simply hides the error message warning that an object being destroyed still has a parent. This property is false by default.
 779     ///
 780     /// In a normal object use case, when ownership of an object is given to a caller, said ownership should be released with efl_unref(). If the object has a parent, this will print error messages, as efl_unref() is stealing the ref from the parent.
 781     ///
 782     /// Warning: Use this function very carefully, unless you&apos;re absolutely sure of what you are doing.
 783     /// (Since EFL 1.22)</summary>
 784     /// <value>Whether to allow efl_unref() to zero even if <see cref="Efl.Object.Parent"/> is not <c>null</c>.</value>
 785     public bool AllowParentUnref {
 786         get { return GetAllowParentUnref(); }
 787         set { SetAllowParentUnref(value); }
 788     }
 789     private static IntPtr GetEflClassStatic()
 790     {
 791         return Efl.Object.efl_object_class_get();
 792     }
 793     /// <summary>Wrapper for native methods and virtual method delegates.
 794     /// For internal use by generated code only.</summary>
 795     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 796     {
 797         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Eo);
 798         /// <summary>Gets the list of Eo operations to override.</summary>
 799         /// <returns>The list of Eo operations to be overload.</returns>
 800         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 801         {
 802             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 803             var methods = Efl.Eo.Globals.GetUserMethods(type);
 804
 805             if (efl_parent_get_static_delegate == null)
 806             {
 807                 efl_parent_get_static_delegate = new efl_parent_get_delegate(parent_get);
 808             }
 809
 810             if (methods.FirstOrDefault(m => m.Name == "GetParent") != null)
 811             {
 812                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_parent_get_static_delegate) });
 813             }
 814
 815             if (efl_parent_set_static_delegate == null)
 816             {
 817                 efl_parent_set_static_delegate = new efl_parent_set_delegate(parent_set);
 818             }
 819
 820             if (methods.FirstOrDefault(m => m.Name == "SetParent") != null)
 821             {
 822                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_parent_set"), func = Marshal.GetFunctionPointerForDelegate(efl_parent_set_static_delegate) });
 823             }
 824
 825             if (efl_name_get_static_delegate == null)
 826             {
 827                 efl_name_get_static_delegate = new efl_name_get_delegate(name_get);
 828             }
 829
 830             if (methods.FirstOrDefault(m => m.Name == "GetName") != null)
 831             {
 832                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_name_get_static_delegate) });
 833             }
 834
 835             if (efl_name_set_static_delegate == null)
 836             {
 837                 efl_name_set_static_delegate = new efl_name_set_delegate(name_set);
 838             }
 839
 840             if (methods.FirstOrDefault(m => m.Name == "SetName") != null)
 841             {
 842                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_name_set"), func = Marshal.GetFunctionPointerForDelegate(efl_name_set_static_delegate) });
 843             }
 844
 845             if (efl_comment_get_static_delegate == null)
 846             {
 847                 efl_comment_get_static_delegate = new efl_comment_get_delegate(comment_get);
 848             }
 849
 850             if (methods.FirstOrDefault(m => m.Name == "GetComment") != null)
 851             {
 852                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_comment_get"), func = Marshal.GetFunctionPointerForDelegate(efl_comment_get_static_delegate) });
 853             }
 854
 855             if (efl_comment_set_static_delegate == null)
 856             {
 857                 efl_comment_set_static_delegate = new efl_comment_set_delegate(comment_set);
 858             }
 859
 860             if (methods.FirstOrDefault(m => m.Name == "SetComment") != null)
 861             {
 862                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_comment_set"), func = Marshal.GetFunctionPointerForDelegate(efl_comment_set_static_delegate) });
 863             }
 864
 865             if (efl_event_freeze_count_get_static_delegate == null)
 866             {
 867                 efl_event_freeze_count_get_static_delegate = new efl_event_freeze_count_get_delegate(event_freeze_count_get);
 868             }
 869
 870             if (methods.FirstOrDefault(m => m.Name == "GetEventFreezeCount") != null)
 871             {
 872                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_event_freeze_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_event_freeze_count_get_static_delegate) });
 873             }
 874
 875             if (efl_finalized_get_static_delegate == null)
 876             {
 877                 efl_finalized_get_static_delegate = new efl_finalized_get_delegate(finalized_get);
 878             }
 879
 880             if (methods.FirstOrDefault(m => m.Name == "GetFinalized") != null)
 881             {
 882                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_finalized_get"), func = Marshal.GetFunctionPointerForDelegate(efl_finalized_get_static_delegate) });
 883             }
 884
 885             if (efl_invalidated_get_static_delegate == null)
 886             {
 887                 efl_invalidated_get_static_delegate = new efl_invalidated_get_delegate(invalidated_get);
 888             }
 889
 890             if (methods.FirstOrDefault(m => m.Name == "GetInvalidated") != null)
 891             {
 892                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_invalidated_get"), func = Marshal.GetFunctionPointerForDelegate(efl_invalidated_get_static_delegate) });
 893             }
 894
 895             if (efl_invalidating_get_static_delegate == null)
 896             {
 897                 efl_invalidating_get_static_delegate = new efl_invalidating_get_delegate(invalidating_get);
 898             }
 899
 900             if (methods.FirstOrDefault(m => m.Name == "GetInvalidating") != null)
 901             {
 902                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_invalidating_get"), func = Marshal.GetFunctionPointerForDelegate(efl_invalidating_get_static_delegate) });
 903             }
 904
 905             if (efl_allow_parent_unref_get_static_delegate == null)
 906             {
 907                 efl_allow_parent_unref_get_static_delegate = new efl_allow_parent_unref_get_delegate(allow_parent_unref_get);
 908             }
 909
 910             if (methods.FirstOrDefault(m => m.Name == "GetAllowParentUnref") != null)
 911             {
 912                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_allow_parent_unref_get"), func = Marshal.GetFunctionPointerForDelegate(efl_allow_parent_unref_get_static_delegate) });
 913             }
 914
 915             if (efl_allow_parent_unref_set_static_delegate == null)
 916             {
 917                 efl_allow_parent_unref_set_static_delegate = new efl_allow_parent_unref_set_delegate(allow_parent_unref_set);
 918             }
 919
 920             if (methods.FirstOrDefault(m => m.Name == "SetAllowParentUnref") != null)
 921             {
 922                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_allow_parent_unref_set"), func = Marshal.GetFunctionPointerForDelegate(efl_allow_parent_unref_set_static_delegate) });
 923             }
 924
 925             if (efl_debug_name_override_static_delegate == null)
 926             {
 927                 efl_debug_name_override_static_delegate = new efl_debug_name_override_delegate(debug_name_override);
 928             }
 929
 930             if (methods.FirstOrDefault(m => m.Name == "DebugNameOverride") != null)
 931             {
 932                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_debug_name_override"), func = Marshal.GetFunctionPointerForDelegate(efl_debug_name_override_static_delegate) });
 933             }
 934
 935             if (efl_provider_find_static_delegate == null)
 936             {
 937                 efl_provider_find_static_delegate = new efl_provider_find_delegate(provider_find);
 938             }
 939
 940             if (methods.FirstOrDefault(m => m.Name == "FindProvider") != null)
 941             {
 942                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_provider_find"), func = Marshal.GetFunctionPointerForDelegate(efl_provider_find_static_delegate) });
 943             }
 944
 945             if (efl_destructor_static_delegate == null)
 946             {
 947                 efl_destructor_static_delegate = new efl_destructor_delegate(destructor);
 948             }
 949
 950             if (methods.FirstOrDefault(m => m.Name == "Destructor") != null)
 951             {
 952                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_destructor"), func = Marshal.GetFunctionPointerForDelegate(efl_destructor_static_delegate) });
 953             }
 954
 955             if (efl_finalize_static_delegate == null)
 956             {
 957                 efl_finalize_static_delegate = new efl_finalize_delegate(finalize);
 958             }
 959
 960             if (methods.FirstOrDefault(m => m.Name == "FinalizeAdd") != null)
 961             {
 962                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_finalize"), func = Marshal.GetFunctionPointerForDelegate(efl_finalize_static_delegate) });
 963             }
 964
 965             if (efl_invalidate_static_delegate == null)
 966             {
 967                 efl_invalidate_static_delegate = new efl_invalidate_delegate(invalidate);
 968             }
 969
 970             if (methods.FirstOrDefault(m => m.Name == "Invalidate") != null)
 971             {
 972                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_invalidate"), func = Marshal.GetFunctionPointerForDelegate(efl_invalidate_static_delegate) });
 973             }
 974
 975             if (efl_name_find_static_delegate == null)
 976             {
 977                 efl_name_find_static_delegate = new efl_name_find_delegate(name_find);
 978             }
 979
 980             if (methods.FirstOrDefault(m => m.Name == "FindName") != null)
 981             {
 982                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_name_find"), func = Marshal.GetFunctionPointerForDelegate(efl_name_find_static_delegate) });
 983             }
 984
 985             if (efl_event_thaw_static_delegate == null)
 986             {
 987                 efl_event_thaw_static_delegate = new efl_event_thaw_delegate(event_thaw);
 988             }
 989
 990             if (methods.FirstOrDefault(m => m.Name == "ThawEvent") != null)
 991             {
 992                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_event_thaw"), func = Marshal.GetFunctionPointerForDelegate(efl_event_thaw_static_delegate) });
 993             }
 994
 995             if (efl_event_freeze_static_delegate == null)
 996             {
 997                 efl_event_freeze_static_delegate = new efl_event_freeze_delegate(event_freeze);
 998             }
 999
1000             if (methods.FirstOrDefault(m => m.Name == "FreezeEvent") != null)
1001             {
1002                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_event_freeze"), func = Marshal.GetFunctionPointerForDelegate(efl_event_freeze_static_delegate) });
1003             }
1004
1005             if (efl_event_callback_stop_static_delegate == null)
1006             {
1007                 efl_event_callback_stop_static_delegate = new efl_event_callback_stop_delegate(event_callback_stop);
1008             }
1009
1010             if (methods.FirstOrDefault(m => m.Name == "EventCallbackStop") != null)
1011             {
1012                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_event_callback_stop"), func = Marshal.GetFunctionPointerForDelegate(efl_event_callback_stop_static_delegate) });
1013             }
1014
1015             if (efl_event_callback_forwarder_del_static_delegate == null)
1016             {
1017                 efl_event_callback_forwarder_del_static_delegate = new efl_event_callback_forwarder_del_delegate(event_callback_forwarder_del);
1018             }
1019
1020             if (methods.FirstOrDefault(m => m.Name == "DelEventCallbackForwarder") != null)
1021             {
1022                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_event_callback_forwarder_del"), func = Marshal.GetFunctionPointerForDelegate(efl_event_callback_forwarder_del_static_delegate) });
1023             }
1024
1025             if (efl_children_iterator_new_static_delegate == null)
1026             {
1027                 efl_children_iterator_new_static_delegate = new efl_children_iterator_new_delegate(children_iterator_new);
1028             }
1029
1030             if (methods.FirstOrDefault(m => m.Name == "NewChildrenIterator") != null)
1031             {
1032                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_children_iterator_new"), func = Marshal.GetFunctionPointerForDelegate(efl_children_iterator_new_static_delegate) });
1033             }
1034
1035             if (efl_composite_attach_static_delegate == null)
1036             {
1037                 efl_composite_attach_static_delegate = new efl_composite_attach_delegate(composite_attach);
1038             }
1039
1040             if (methods.FirstOrDefault(m => m.Name == "AttachComposite") != null)
1041             {
1042                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_composite_attach"), func = Marshal.GetFunctionPointerForDelegate(efl_composite_attach_static_delegate) });
1043             }
1044
1045             if (efl_composite_detach_static_delegate == null)
1046             {
1047                 efl_composite_detach_static_delegate = new efl_composite_detach_delegate(composite_detach);
1048             }
1049
1050             if (methods.FirstOrDefault(m => m.Name == "CompositeDetach") != null)
1051             {
1052                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_composite_detach"), func = Marshal.GetFunctionPointerForDelegate(efl_composite_detach_static_delegate) });
1053             }
1054
1055             if (efl_composite_part_is_static_delegate == null)
1056             {
1057                 efl_composite_part_is_static_delegate = new efl_composite_part_is_delegate(composite_part_is);
1058             }
1059
1060             if (methods.FirstOrDefault(m => m.Name == "IsCompositePart") != null)
1061             {
1062                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_composite_part_is"), func = Marshal.GetFunctionPointerForDelegate(efl_composite_part_is_static_delegate) });
1063             }
1064
1065             descs.AddRange(base.GetEoOps(type));
1066             return descs;
1067         }
1068         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1069         /// <returns>The native class pointer.</returns>
1070         public override IntPtr GetEflClass()
1071         {
1072             return Efl.Object.efl_object_class_get();
1073         }
1074
1075         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1076
1077         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1078         private delegate Efl.Object efl_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
1079
1080         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1081         public delegate Efl.Object efl_parent_get_api_delegate(System.IntPtr obj);
1082
1083         public static Efl.Eo.FunctionWrapper<efl_parent_get_api_delegate> efl_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_parent_get_api_delegate>(Module, "efl_parent_get");
1084
1085         private static Efl.Object parent_get(System.IntPtr obj, System.IntPtr pd)
1086         {
1087             Eina.Log.Debug("function efl_parent_get was called");
1088             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1089             if (ws != null)
1090             {
1091             Efl.Object _ret_var = default(Efl.Object);
1092                 try
1093                 {
1094                     _ret_var = ((Object)ws.Target).GetParent();
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100                 }
1101
1102         return _ret_var;
1103
1104             }
1105             else
1106             {
1107                 return efl_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1108             }
1109         }
1110
1111         private static efl_parent_get_delegate efl_parent_get_static_delegate;
1112
1113
1114         private delegate void efl_parent_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object parent);
1115
1116
1117         public delegate void efl_parent_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object parent);
1118
1119         public static Efl.Eo.FunctionWrapper<efl_parent_set_api_delegate> efl_parent_set_ptr = new Efl.Eo.FunctionWrapper<efl_parent_set_api_delegate>(Module, "efl_parent_set");
1120
1121         private static void parent_set(System.IntPtr obj, System.IntPtr pd, Efl.Object parent)
1122         {
1123             Eina.Log.Debug("function efl_parent_set was called");
1124             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1125             if (ws != null)
1126             {
1127
1128                 try
1129                 {
1130                     ((Object)ws.Target).SetParent(parent);
1131                 }
1132                 catch (Exception e)
1133                 {
1134                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1135                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1136                 }
1137
1138
1139             }
1140             else
1141             {
1142                 efl_parent_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), parent);
1143             }
1144         }
1145
1146         private static efl_parent_set_delegate efl_parent_set_static_delegate;
1147
1148         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1149         private delegate System.String efl_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
1150
1151         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1152         public delegate System.String efl_name_get_api_delegate(System.IntPtr obj);
1153
1154         public static Efl.Eo.FunctionWrapper<efl_name_get_api_delegate> efl_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_name_get_api_delegate>(Module, "efl_name_get");
1155
1156         private static System.String name_get(System.IntPtr obj, System.IntPtr pd)
1157         {
1158             Eina.Log.Debug("function efl_name_get was called");
1159             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1160             if (ws != null)
1161             {
1162             System.String _ret_var = default(System.String);
1163                 try
1164                 {
1165                     _ret_var = ((Object)ws.Target).GetName();
1166                 }
1167                 catch (Exception e)
1168                 {
1169                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1170                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1171                 }
1172
1173         return _ret_var;
1174
1175             }
1176             else
1177             {
1178                 return efl_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1179             }
1180         }
1181
1182         private static efl_name_get_delegate efl_name_get_static_delegate;
1183
1184
1185         private delegate void efl_name_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
1186
1187
1188         public delegate void efl_name_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
1189
1190         public static Efl.Eo.FunctionWrapper<efl_name_set_api_delegate> efl_name_set_ptr = new Efl.Eo.FunctionWrapper<efl_name_set_api_delegate>(Module, "efl_name_set");
1191
1192         private static void name_set(System.IntPtr obj, System.IntPtr pd, System.String name)
1193         {
1194             Eina.Log.Debug("function efl_name_set was called");
1195             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1196             if (ws != null)
1197             {
1198
1199                 try
1200                 {
1201                     ((Object)ws.Target).SetName(name);
1202                 }
1203                 catch (Exception e)
1204                 {
1205                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1206                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1207                 }
1208
1209
1210             }
1211             else
1212             {
1213                 efl_name_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
1214             }
1215         }
1216
1217         private static efl_name_set_delegate efl_name_set_static_delegate;
1218
1219         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1220         private delegate System.String efl_comment_get_delegate(System.IntPtr obj, System.IntPtr pd);
1221
1222         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1223         public delegate System.String efl_comment_get_api_delegate(System.IntPtr obj);
1224
1225         public static Efl.Eo.FunctionWrapper<efl_comment_get_api_delegate> efl_comment_get_ptr = new Efl.Eo.FunctionWrapper<efl_comment_get_api_delegate>(Module, "efl_comment_get");
1226
1227         private static System.String comment_get(System.IntPtr obj, System.IntPtr pd)
1228         {
1229             Eina.Log.Debug("function efl_comment_get was called");
1230             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1231             if (ws != null)
1232             {
1233             System.String _ret_var = default(System.String);
1234                 try
1235                 {
1236                     _ret_var = ((Object)ws.Target).GetComment();
1237                 }
1238                 catch (Exception e)
1239                 {
1240                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1241                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1242                 }
1243
1244         return _ret_var;
1245
1246             }
1247             else
1248             {
1249                 return efl_comment_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1250             }
1251         }
1252
1253         private static efl_comment_get_delegate efl_comment_get_static_delegate;
1254
1255
1256         private delegate void efl_comment_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String comment);
1257
1258
1259         public delegate void efl_comment_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String comment);
1260
1261         public static Efl.Eo.FunctionWrapper<efl_comment_set_api_delegate> efl_comment_set_ptr = new Efl.Eo.FunctionWrapper<efl_comment_set_api_delegate>(Module, "efl_comment_set");
1262
1263         private static void comment_set(System.IntPtr obj, System.IntPtr pd, System.String comment)
1264         {
1265             Eina.Log.Debug("function efl_comment_set was called");
1266             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1267             if (ws != null)
1268             {
1269
1270                 try
1271                 {
1272                     ((Object)ws.Target).SetComment(comment);
1273                 }
1274                 catch (Exception e)
1275                 {
1276                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1277                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1278                 }
1279
1280
1281             }
1282             else
1283             {
1284                 efl_comment_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), comment);
1285             }
1286         }
1287
1288         private static efl_comment_set_delegate efl_comment_set_static_delegate;
1289
1290
1291         private delegate int efl_event_global_freeze_count_get_delegate();
1292
1293
1294         public delegate int efl_event_global_freeze_count_get_api_delegate();
1295
1296         public static Efl.Eo.FunctionWrapper<efl_event_global_freeze_count_get_api_delegate> efl_event_global_freeze_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_event_global_freeze_count_get_api_delegate>(Module, "efl_event_global_freeze_count_get");
1297
1298         private static int event_global_freeze_count_get(System.IntPtr obj, System.IntPtr pd)
1299         {
1300             Eina.Log.Debug("function efl_event_global_freeze_count_get was called");
1301             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1302             if (ws != null)
1303             {
1304             int _ret_var = default(int);
1305                 try
1306                 {
1307                     _ret_var = Object.GetEventGlobalFreezeCount();
1308                 }
1309                 catch (Exception e)
1310                 {
1311                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1312                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1313                 }
1314
1315         return _ret_var;
1316
1317             }
1318             else
1319             {
1320                 return efl_event_global_freeze_count_get_ptr.Value.Delegate();
1321             }
1322         }
1323
1324
1325         private delegate int efl_event_freeze_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1326
1327
1328         public delegate int efl_event_freeze_count_get_api_delegate(System.IntPtr obj);
1329
1330         public static Efl.Eo.FunctionWrapper<efl_event_freeze_count_get_api_delegate> efl_event_freeze_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_event_freeze_count_get_api_delegate>(Module, "efl_event_freeze_count_get");
1331
1332         private static int event_freeze_count_get(System.IntPtr obj, System.IntPtr pd)
1333         {
1334             Eina.Log.Debug("function efl_event_freeze_count_get was called");
1335             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1336             if (ws != null)
1337             {
1338             int _ret_var = default(int);
1339                 try
1340                 {
1341                     _ret_var = ((Object)ws.Target).GetEventFreezeCount();
1342                 }
1343                 catch (Exception e)
1344                 {
1345                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1346                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1347                 }
1348
1349         return _ret_var;
1350
1351             }
1352             else
1353             {
1354                 return efl_event_freeze_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1355             }
1356         }
1357
1358         private static efl_event_freeze_count_get_delegate efl_event_freeze_count_get_static_delegate;
1359
1360         [return: MarshalAs(UnmanagedType.U1)]
1361         private delegate bool efl_finalized_get_delegate(System.IntPtr obj, System.IntPtr pd);
1362
1363         [return: MarshalAs(UnmanagedType.U1)]
1364         public delegate bool efl_finalized_get_api_delegate(System.IntPtr obj);
1365
1366         public static Efl.Eo.FunctionWrapper<efl_finalized_get_api_delegate> efl_finalized_get_ptr = new Efl.Eo.FunctionWrapper<efl_finalized_get_api_delegate>(Module, "efl_finalized_get");
1367
1368         private static bool finalized_get(System.IntPtr obj, System.IntPtr pd)
1369         {
1370             Eina.Log.Debug("function efl_finalized_get was called");
1371             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1372             if (ws != null)
1373             {
1374             bool _ret_var = default(bool);
1375                 try
1376                 {
1377                     _ret_var = ((Object)ws.Target).GetFinalized();
1378                 }
1379                 catch (Exception e)
1380                 {
1381                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1382                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1383                 }
1384
1385         return _ret_var;
1386
1387             }
1388             else
1389             {
1390                 return efl_finalized_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1391             }
1392         }
1393
1394         private static efl_finalized_get_delegate efl_finalized_get_static_delegate;
1395
1396         [return: MarshalAs(UnmanagedType.U1)]
1397         private delegate bool efl_invalidated_get_delegate(System.IntPtr obj, System.IntPtr pd);
1398
1399         [return: MarshalAs(UnmanagedType.U1)]
1400         public delegate bool efl_invalidated_get_api_delegate(System.IntPtr obj);
1401
1402         public static Efl.Eo.FunctionWrapper<efl_invalidated_get_api_delegate> efl_invalidated_get_ptr = new Efl.Eo.FunctionWrapper<efl_invalidated_get_api_delegate>(Module, "efl_invalidated_get");
1403
1404         private static bool invalidated_get(System.IntPtr obj, System.IntPtr pd)
1405         {
1406             Eina.Log.Debug("function efl_invalidated_get was called");
1407             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1408             if (ws != null)
1409             {
1410             bool _ret_var = default(bool);
1411                 try
1412                 {
1413                     _ret_var = ((Object)ws.Target).GetInvalidated();
1414                 }
1415                 catch (Exception e)
1416                 {
1417                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1418                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1419                 }
1420
1421         return _ret_var;
1422
1423             }
1424             else
1425             {
1426                 return efl_invalidated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1427             }
1428         }
1429
1430         private static efl_invalidated_get_delegate efl_invalidated_get_static_delegate;
1431
1432         [return: MarshalAs(UnmanagedType.U1)]
1433         private delegate bool efl_invalidating_get_delegate(System.IntPtr obj, System.IntPtr pd);
1434
1435         [return: MarshalAs(UnmanagedType.U1)]
1436         public delegate bool efl_invalidating_get_api_delegate(System.IntPtr obj);
1437
1438         public static Efl.Eo.FunctionWrapper<efl_invalidating_get_api_delegate> efl_invalidating_get_ptr = new Efl.Eo.FunctionWrapper<efl_invalidating_get_api_delegate>(Module, "efl_invalidating_get");
1439
1440         private static bool invalidating_get(System.IntPtr obj, System.IntPtr pd)
1441         {
1442             Eina.Log.Debug("function efl_invalidating_get was called");
1443             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1444             if (ws != null)
1445             {
1446             bool _ret_var = default(bool);
1447                 try
1448                 {
1449                     _ret_var = ((Object)ws.Target).GetInvalidating();
1450                 }
1451                 catch (Exception e)
1452                 {
1453                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1454                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1455                 }
1456
1457         return _ret_var;
1458
1459             }
1460             else
1461             {
1462                 return efl_invalidating_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1463             }
1464         }
1465
1466         private static efl_invalidating_get_delegate efl_invalidating_get_static_delegate;
1467
1468         [return: MarshalAs(UnmanagedType.U1)]
1469         private delegate bool efl_allow_parent_unref_get_delegate(System.IntPtr obj, System.IntPtr pd);
1470
1471         [return: MarshalAs(UnmanagedType.U1)]
1472         public delegate bool efl_allow_parent_unref_get_api_delegate(System.IntPtr obj);
1473
1474         public static Efl.Eo.FunctionWrapper<efl_allow_parent_unref_get_api_delegate> efl_allow_parent_unref_get_ptr = new Efl.Eo.FunctionWrapper<efl_allow_parent_unref_get_api_delegate>(Module, "efl_allow_parent_unref_get");
1475
1476         private static bool allow_parent_unref_get(System.IntPtr obj, System.IntPtr pd)
1477         {
1478             Eina.Log.Debug("function efl_allow_parent_unref_get was called");
1479             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1480             if (ws != null)
1481             {
1482             bool _ret_var = default(bool);
1483                 try
1484                 {
1485                     _ret_var = ((Object)ws.Target).GetAllowParentUnref();
1486                 }
1487                 catch (Exception e)
1488                 {
1489                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1490                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1491                 }
1492
1493         return _ret_var;
1494
1495             }
1496             else
1497             {
1498                 return efl_allow_parent_unref_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1499             }
1500         }
1501
1502         private static efl_allow_parent_unref_get_delegate efl_allow_parent_unref_get_static_delegate;
1503
1504
1505         private delegate void efl_allow_parent_unref_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool allow);
1506
1507
1508         public delegate void efl_allow_parent_unref_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool allow);
1509
1510         public static Efl.Eo.FunctionWrapper<efl_allow_parent_unref_set_api_delegate> efl_allow_parent_unref_set_ptr = new Efl.Eo.FunctionWrapper<efl_allow_parent_unref_set_api_delegate>(Module, "efl_allow_parent_unref_set");
1511
1512         private static void allow_parent_unref_set(System.IntPtr obj, System.IntPtr pd, bool allow)
1513         {
1514             Eina.Log.Debug("function efl_allow_parent_unref_set was called");
1515             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1516             if (ws != null)
1517             {
1518
1519                 try
1520                 {
1521                     ((Object)ws.Target).SetAllowParentUnref(allow);
1522                 }
1523                 catch (Exception e)
1524                 {
1525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1527                 }
1528
1529
1530             }
1531             else
1532             {
1533                 efl_allow_parent_unref_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), allow);
1534             }
1535         }
1536
1537         private static efl_allow_parent_unref_set_delegate efl_allow_parent_unref_set_static_delegate;
1538
1539
1540         private delegate void efl_debug_name_override_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf sb);
1541
1542
1543         public delegate void efl_debug_name_override_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf sb);
1544
1545         public static Efl.Eo.FunctionWrapper<efl_debug_name_override_api_delegate> efl_debug_name_override_ptr = new Efl.Eo.FunctionWrapper<efl_debug_name_override_api_delegate>(Module, "efl_debug_name_override");
1546
1547         private static void debug_name_override(System.IntPtr obj, System.IntPtr pd, Eina.Strbuf sb)
1548         {
1549             Eina.Log.Debug("function efl_debug_name_override was called");
1550             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1551             if (ws != null)
1552             {
1553
1554                 try
1555                 {
1556                     ((Object)ws.Target).DebugNameOverride(sb);
1557                 }
1558                 catch (Exception e)
1559                 {
1560                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1561                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1562                 }
1563
1564
1565             }
1566             else
1567             {
1568                 efl_debug_name_override_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sb);
1569             }
1570         }
1571
1572         private static efl_debug_name_override_delegate efl_debug_name_override_static_delegate;
1573
1574         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1575         private delegate Efl.Object efl_provider_find_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEflClass))] Type klass);
1576
1577         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1578         public delegate Efl.Object efl_provider_find_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEflClass))] Type klass);
1579
1580         public static Efl.Eo.FunctionWrapper<efl_provider_find_api_delegate> efl_provider_find_ptr = new Efl.Eo.FunctionWrapper<efl_provider_find_api_delegate>(Module, "efl_provider_find");
1581
1582         private static Efl.Object provider_find(System.IntPtr obj, System.IntPtr pd, Type klass)
1583         {
1584             Eina.Log.Debug("function efl_provider_find was called");
1585             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1586             if (ws != null)
1587             {
1588                                     Efl.Object _ret_var = default(Efl.Object);
1589                 try
1590                 {
1591                     _ret_var = ((Object)ws.Target).FindProvider(klass);
1592                 }
1593                 catch (Exception e)
1594                 {
1595                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1596                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1597                 }
1598
1599                         return _ret_var;
1600
1601             }
1602             else
1603             {
1604                 return efl_provider_find_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), klass);
1605             }
1606         }
1607
1608         private static efl_provider_find_delegate efl_provider_find_static_delegate;
1609
1610
1611         private delegate void efl_destructor_delegate(System.IntPtr obj, System.IntPtr pd);
1612
1613
1614         public delegate void efl_destructor_api_delegate(System.IntPtr obj);
1615
1616         public static Efl.Eo.FunctionWrapper<efl_destructor_api_delegate> efl_destructor_ptr = new Efl.Eo.FunctionWrapper<efl_destructor_api_delegate>(Module, "efl_destructor");
1617
1618         private static void destructor(System.IntPtr obj, System.IntPtr pd)
1619         {
1620             Eina.Log.Debug("function efl_destructor was called");
1621             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1622             if (ws != null)
1623             {
1624
1625                 try
1626                 {
1627                     ((Object)ws.Target).Destructor();
1628                 }
1629                 catch (Exception e)
1630                 {
1631                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1632                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1633                 }
1634
1635
1636             }
1637             else
1638             {
1639                 efl_destructor_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1640             }
1641         }
1642
1643         private static efl_destructor_delegate efl_destructor_static_delegate;
1644
1645         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1646         private delegate Efl.Object efl_finalize_delegate(System.IntPtr obj, System.IntPtr pd);
1647
1648         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1649         public delegate Efl.Object efl_finalize_api_delegate(System.IntPtr obj);
1650
1651         public static Efl.Eo.FunctionWrapper<efl_finalize_api_delegate> efl_finalize_ptr = new Efl.Eo.FunctionWrapper<efl_finalize_api_delegate>(Module, "efl_finalize");
1652
1653         private static Efl.Object finalize(System.IntPtr obj, System.IntPtr pd)
1654         {
1655             Eina.Log.Debug("function efl_finalize was called");
1656             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1657             if (ws != null)
1658             {
1659             Efl.Object _ret_var = default(Efl.Object);
1660                 try
1661                 {
1662                     _ret_var = ((Object)ws.Target).FinalizeAdd();
1663                 }
1664                 catch (Exception e)
1665                 {
1666                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1667                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1668                 }
1669
1670         return _ret_var;
1671
1672             }
1673             else
1674             {
1675                 return efl_finalize_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1676             }
1677         }
1678
1679         private static efl_finalize_delegate efl_finalize_static_delegate;
1680
1681
1682         private delegate void efl_invalidate_delegate(System.IntPtr obj, System.IntPtr pd);
1683
1684
1685         public delegate void efl_invalidate_api_delegate(System.IntPtr obj);
1686
1687         public static Efl.Eo.FunctionWrapper<efl_invalidate_api_delegate> efl_invalidate_ptr = new Efl.Eo.FunctionWrapper<efl_invalidate_api_delegate>(Module, "efl_invalidate");
1688
1689         private static void invalidate(System.IntPtr obj, System.IntPtr pd)
1690         {
1691             Eina.Log.Debug("function efl_invalidate was called");
1692             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1693             if (ws != null)
1694             {
1695
1696                 try
1697                 {
1698                     ((Object)ws.Target).Invalidate();
1699                 }
1700                 catch (Exception e)
1701                 {
1702                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1703                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1704                 }
1705
1706
1707             }
1708             else
1709             {
1710                 efl_invalidate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1711             }
1712         }
1713
1714         private static efl_invalidate_delegate efl_invalidate_static_delegate;
1715
1716         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1717         private delegate Efl.Object efl_name_find_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String search);
1718
1719         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1720         public delegate Efl.Object efl_name_find_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String search);
1721
1722         public static Efl.Eo.FunctionWrapper<efl_name_find_api_delegate> efl_name_find_ptr = new Efl.Eo.FunctionWrapper<efl_name_find_api_delegate>(Module, "efl_name_find");
1723
1724         private static Efl.Object name_find(System.IntPtr obj, System.IntPtr pd, System.String search)
1725         {
1726             Eina.Log.Debug("function efl_name_find was called");
1727             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1728             if (ws != null)
1729             {
1730                                     Efl.Object _ret_var = default(Efl.Object);
1731                 try
1732                 {
1733                     _ret_var = ((Object)ws.Target).FindName(search);
1734                 }
1735                 catch (Exception e)
1736                 {
1737                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1738                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1739                 }
1740
1741                         return _ret_var;
1742
1743             }
1744             else
1745             {
1746                 return efl_name_find_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), search);
1747             }
1748         }
1749
1750         private static efl_name_find_delegate efl_name_find_static_delegate;
1751
1752
1753         private delegate void efl_event_thaw_delegate(System.IntPtr obj, System.IntPtr pd);
1754
1755
1756         public delegate void efl_event_thaw_api_delegate(System.IntPtr obj);
1757
1758         public static Efl.Eo.FunctionWrapper<efl_event_thaw_api_delegate> efl_event_thaw_ptr = new Efl.Eo.FunctionWrapper<efl_event_thaw_api_delegate>(Module, "efl_event_thaw");
1759
1760         private static void event_thaw(System.IntPtr obj, System.IntPtr pd)
1761         {
1762             Eina.Log.Debug("function efl_event_thaw was called");
1763             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1764             if (ws != null)
1765             {
1766
1767                 try
1768                 {
1769                     ((Object)ws.Target).ThawEvent();
1770                 }
1771                 catch (Exception e)
1772                 {
1773                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1774                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1775                 }
1776
1777
1778             }
1779             else
1780             {
1781                 efl_event_thaw_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1782             }
1783         }
1784
1785         private static efl_event_thaw_delegate efl_event_thaw_static_delegate;
1786
1787
1788         private delegate void efl_event_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
1789
1790
1791         public delegate void efl_event_freeze_api_delegate(System.IntPtr obj);
1792
1793         public static Efl.Eo.FunctionWrapper<efl_event_freeze_api_delegate> efl_event_freeze_ptr = new Efl.Eo.FunctionWrapper<efl_event_freeze_api_delegate>(Module, "efl_event_freeze");
1794
1795         private static void event_freeze(System.IntPtr obj, System.IntPtr pd)
1796         {
1797             Eina.Log.Debug("function efl_event_freeze was called");
1798             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1799             if (ws != null)
1800             {
1801
1802                 try
1803                 {
1804                     ((Object)ws.Target).FreezeEvent();
1805                 }
1806                 catch (Exception e)
1807                 {
1808                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1809                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1810                 }
1811
1812
1813             }
1814             else
1815             {
1816                 efl_event_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1817             }
1818         }
1819
1820         private static efl_event_freeze_delegate efl_event_freeze_static_delegate;
1821
1822
1823         private delegate void efl_event_global_thaw_delegate();
1824
1825
1826         public delegate void efl_event_global_thaw_api_delegate();
1827
1828         public static Efl.Eo.FunctionWrapper<efl_event_global_thaw_api_delegate> efl_event_global_thaw_ptr = new Efl.Eo.FunctionWrapper<efl_event_global_thaw_api_delegate>(Module, "efl_event_global_thaw");
1829
1830         private static void event_global_thaw(System.IntPtr obj, System.IntPtr pd)
1831         {
1832             Eina.Log.Debug("function efl_event_global_thaw was called");
1833             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1834             if (ws != null)
1835             {
1836
1837                 try
1838                 {
1839                     Object.ThawEventGlobal();
1840                 }
1841                 catch (Exception e)
1842                 {
1843                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1844                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1845                 }
1846
1847
1848             }
1849             else
1850             {
1851                 efl_event_global_thaw_ptr.Value.Delegate();
1852             }
1853         }
1854
1855
1856         private delegate void efl_event_global_freeze_delegate();
1857
1858
1859         public delegate void efl_event_global_freeze_api_delegate();
1860
1861         public static Efl.Eo.FunctionWrapper<efl_event_global_freeze_api_delegate> efl_event_global_freeze_ptr = new Efl.Eo.FunctionWrapper<efl_event_global_freeze_api_delegate>(Module, "efl_event_global_freeze");
1862
1863         private static void event_global_freeze(System.IntPtr obj, System.IntPtr pd)
1864         {
1865             Eina.Log.Debug("function efl_event_global_freeze was called");
1866             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1867             if (ws != null)
1868             {
1869
1870                 try
1871                 {
1872                     Object.FreezeEventGlobal();
1873                 }
1874                 catch (Exception e)
1875                 {
1876                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1877                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1878                 }
1879
1880
1881             }
1882             else
1883             {
1884                 efl_event_global_freeze_ptr.Value.Delegate();
1885             }
1886         }
1887
1888
1889         private delegate void efl_event_callback_stop_delegate(System.IntPtr obj, System.IntPtr pd);
1890
1891
1892         public delegate void efl_event_callback_stop_api_delegate(System.IntPtr obj);
1893
1894         public static Efl.Eo.FunctionWrapper<efl_event_callback_stop_api_delegate> efl_event_callback_stop_ptr = new Efl.Eo.FunctionWrapper<efl_event_callback_stop_api_delegate>(Module, "efl_event_callback_stop");
1895
1896         private static void event_callback_stop(System.IntPtr obj, System.IntPtr pd)
1897         {
1898             Eina.Log.Debug("function efl_event_callback_stop was called");
1899             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1900             if (ws != null)
1901             {
1902
1903                 try
1904                 {
1905                     ((Object)ws.Target).EventCallbackStop();
1906                 }
1907                 catch (Exception e)
1908                 {
1909                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1910                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1911                 }
1912
1913
1914             }
1915             else
1916             {
1917                 efl_event_callback_stop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1918             }
1919         }
1920
1921         private static efl_event_callback_stop_delegate efl_event_callback_stop_static_delegate;
1922
1923
1924         private delegate void efl_event_callback_forwarder_del_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr desc, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object new_obj);
1925
1926
1927         public delegate void efl_event_callback_forwarder_del_api_delegate(System.IntPtr obj,  System.IntPtr desc, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object new_obj);
1928
1929         public static Efl.Eo.FunctionWrapper<efl_event_callback_forwarder_del_api_delegate> efl_event_callback_forwarder_del_ptr = new Efl.Eo.FunctionWrapper<efl_event_callback_forwarder_del_api_delegate>(Module, "efl_event_callback_forwarder_del");
1930
1931         private static void event_callback_forwarder_del(System.IntPtr obj, System.IntPtr pd, System.IntPtr desc, Efl.Object new_obj)
1932         {
1933             Eina.Log.Debug("function efl_event_callback_forwarder_del was called");
1934             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1935             if (ws != null)
1936             {
1937         var _in_desc = Eina.PrimitiveConversion.PointerToManaged<Efl.EventDescription>(desc);
1938
1939                 try
1940                 {
1941                     ((Object)ws.Target).DelEventCallbackForwarder(_in_desc, new_obj);
1942                 }
1943                 catch (Exception e)
1944                 {
1945                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1946                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1947                 }
1948
1949
1950             }
1951             else
1952             {
1953                 efl_event_callback_forwarder_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), desc, new_obj);
1954             }
1955         }
1956
1957         private static efl_event_callback_forwarder_del_delegate efl_event_callback_forwarder_del_static_delegate;
1958
1959
1960         private delegate System.IntPtr efl_children_iterator_new_delegate(System.IntPtr obj, System.IntPtr pd);
1961
1962
1963         public delegate System.IntPtr efl_children_iterator_new_api_delegate(System.IntPtr obj);
1964
1965         public static Efl.Eo.FunctionWrapper<efl_children_iterator_new_api_delegate> efl_children_iterator_new_ptr = new Efl.Eo.FunctionWrapper<efl_children_iterator_new_api_delegate>(Module, "efl_children_iterator_new");
1966
1967         private static System.IntPtr children_iterator_new(System.IntPtr obj, System.IntPtr pd)
1968         {
1969             Eina.Log.Debug("function efl_children_iterator_new was called");
1970             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1971             if (ws != null)
1972             {
1973             Eina.Iterator<Efl.Object> _ret_var = default(Eina.Iterator<Efl.Object>);
1974                 try
1975                 {
1976                     _ret_var = ((Object)ws.Target).NewChildrenIterator();
1977                 }
1978                 catch (Exception e)
1979                 {
1980                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1981                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1982                 }
1983
1984         _ret_var.Own = false; return _ret_var.Handle;
1985
1986             }
1987             else
1988             {
1989                 return efl_children_iterator_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1990             }
1991         }
1992
1993         private static efl_children_iterator_new_delegate efl_children_iterator_new_static_delegate;
1994
1995         [return: MarshalAs(UnmanagedType.U1)]
1996         private delegate bool efl_composite_attach_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object comp_obj);
1997
1998         [return: MarshalAs(UnmanagedType.U1)]
1999         public delegate bool efl_composite_attach_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object comp_obj);
2000
2001         public static Efl.Eo.FunctionWrapper<efl_composite_attach_api_delegate> efl_composite_attach_ptr = new Efl.Eo.FunctionWrapper<efl_composite_attach_api_delegate>(Module, "efl_composite_attach");
2002
2003         private static bool composite_attach(System.IntPtr obj, System.IntPtr pd, Efl.Object comp_obj)
2004         {
2005             Eina.Log.Debug("function efl_composite_attach was called");
2006             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2007             if (ws != null)
2008             {
2009                                     bool _ret_var = default(bool);
2010                 try
2011                 {
2012                     _ret_var = ((Object)ws.Target).AttachComposite(comp_obj);
2013                 }
2014                 catch (Exception e)
2015                 {
2016                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2017                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2018                 }
2019
2020                         return _ret_var;
2021
2022             }
2023             else
2024             {
2025                 return efl_composite_attach_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), comp_obj);
2026             }
2027         }
2028
2029         private static efl_composite_attach_delegate efl_composite_attach_static_delegate;
2030
2031         [return: MarshalAs(UnmanagedType.U1)]
2032         private delegate bool efl_composite_detach_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object comp_obj);
2033
2034         [return: MarshalAs(UnmanagedType.U1)]
2035         public delegate bool efl_composite_detach_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object comp_obj);
2036
2037         public static Efl.Eo.FunctionWrapper<efl_composite_detach_api_delegate> efl_composite_detach_ptr = new Efl.Eo.FunctionWrapper<efl_composite_detach_api_delegate>(Module, "efl_composite_detach");
2038
2039         private static bool composite_detach(System.IntPtr obj, System.IntPtr pd, Efl.Object comp_obj)
2040         {
2041             Eina.Log.Debug("function efl_composite_detach was called");
2042             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2043             if (ws != null)
2044             {
2045                                     bool _ret_var = default(bool);
2046                 try
2047                 {
2048                     _ret_var = ((Object)ws.Target).CompositeDetach(comp_obj);
2049                 }
2050                 catch (Exception e)
2051                 {
2052                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2053                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2054                 }
2055
2056                         return _ret_var;
2057
2058             }
2059             else
2060             {
2061                 return efl_composite_detach_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), comp_obj);
2062             }
2063         }
2064
2065         private static efl_composite_detach_delegate efl_composite_detach_static_delegate;
2066
2067         [return: MarshalAs(UnmanagedType.U1)]
2068         private delegate bool efl_composite_part_is_delegate(System.IntPtr obj, System.IntPtr pd);
2069
2070         [return: MarshalAs(UnmanagedType.U1)]
2071         public delegate bool efl_composite_part_is_api_delegate(System.IntPtr obj);
2072
2073         public static Efl.Eo.FunctionWrapper<efl_composite_part_is_api_delegate> efl_composite_part_is_ptr = new Efl.Eo.FunctionWrapper<efl_composite_part_is_api_delegate>(Module, "efl_composite_part_is");
2074
2075         private static bool composite_part_is(System.IntPtr obj, System.IntPtr pd)
2076         {
2077             Eina.Log.Debug("function efl_composite_part_is was called");
2078             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2079             if (ws != null)
2080             {
2081             bool _ret_var = default(bool);
2082                 try
2083                 {
2084                     _ret_var = ((Object)ws.Target).IsCompositePart();
2085                 }
2086                 catch (Exception e)
2087                 {
2088                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2089                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2090                 }
2091
2092         return _ret_var;
2093
2094             }
2095             else
2096             {
2097                 return efl_composite_part_is_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2098             }
2099         }
2100
2101         private static efl_composite_part_is_delegate efl_composite_part_is_static_delegate;
2102
2103         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2104
2105 }
2106 }
2107 }
2108
2109 namespace Efl {
2110
2111 /// <summary>A parameter passed in event callbacks holding extra event parameters.
2112 /// This is the full event information passed to callbacks in C.
2113 /// (Since EFL 1.22)</summary>
2114 [StructLayout(LayoutKind.Sequential)]
2115 [Efl.Eo.BindingEntity]
2116 public struct Event
2117 {
2118     /// <summary>The object the callback was called on.
2119     /// (Since EFL 1.22)</summary>
2120     public Efl.Object Object;
2121     /// <summary>The event description.
2122     /// (Since EFL 1.22)</summary>
2123     public Efl.EventDescription Desc;
2124     /// <summary>Extra event information passed by the event caller. Must be cast to the event type declared in the EO file. Keep in mind that: 1) Objects are passed as a normal Eo*. Event subscribers can call functions on these objects. 2) Structs, built-in types and containers are passed as const pointers, with one level of indirection.
2125     /// (Since EFL 1.22)</summary>
2126     public System.IntPtr Info;
2127     ///<summary>Constructor for Event.</summary>
2128     public Event(
2129         Efl.Object Object = default(Efl.Object),
2130         Efl.EventDescription Desc = default(Efl.EventDescription),
2131         System.IntPtr Info = default(System.IntPtr)    )
2132     {
2133         this.Object = Object;
2134         this.Desc = Desc;
2135         this.Info = Info;
2136     }
2137
2138     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
2139     ///<param name="ptr">Native pointer to be converted.</param>
2140     public static implicit operator Event(IntPtr ptr)
2141     {
2142         var tmp = (Event.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Event.NativeStruct));
2143         return tmp;
2144     }
2145
2146     #pragma warning disable CS1591
2147
2148     ///<summary>Internal wrapper for struct Event.</summary>
2149     [StructLayout(LayoutKind.Sequential)]
2150     public struct NativeStruct
2151     {
2152         ///<summary>Internal wrapper for field Object</summary>
2153         public System.IntPtr Object;
2154
2155         public System.IntPtr Desc;
2156
2157         public System.IntPtr Info;
2158         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
2159         public static implicit operator Event.NativeStruct(Event _external_struct)
2160         {
2161             var _internal_struct = new Event.NativeStruct();
2162             _internal_struct.Object = _external_struct.Object?.NativeHandle ?? System.IntPtr.Zero;
2163             _internal_struct.Desc = Eina.PrimitiveConversion.ManagedToPointerAlloc(_external_struct.Desc);
2164             _internal_struct.Info = _external_struct.Info;
2165             return _internal_struct;
2166         }
2167
2168         ///<summary>Implicit conversion to the managed representation.</summary>
2169         public static implicit operator Event(Event.NativeStruct _internal_struct)
2170         {
2171             var _external_struct = new Event();
2172
2173             _external_struct.Object = (Efl.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Object);
2174             _external_struct.Desc = Eina.PrimitiveConversion.PointerToManaged<Efl.EventDescription>(_internal_struct.Desc);
2175             _external_struct.Info = _internal_struct.Info;
2176             return _external_struct;
2177         }
2178
2179     }
2180
2181     #pragma warning restore CS1591
2182
2183 }
2184
2185 }
2186