internals/src/EflSharp/EflSharp/efl/efl_canvas_group.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 namespace Canvas {
  11
  12 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.Group.MemberAddedEvt"/>.</summary>
  13 public class GroupMemberAddedEvt_Args : EventArgs {
  14     ///<summary>Actual event payload.</summary>
  15     public Efl.Gfx.IEntity arg { get; set; }
  16 }
  17 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.Group.MemberRemovedEvt"/>.</summary>
  18 public class GroupMemberRemovedEvt_Args : EventArgs {
  19     ///<summary>Actual event payload.</summary>
  20     public Efl.Gfx.IEntity arg { get; set; }
  21 }
  22 /// <summary>A group object is a container for other canvas objects. Its children move along their parent and are often clipped with a common clipper. This is part of the legacy smart object concept.
  23 /// A group is not necessarily a container (see <see cref="Efl.IContainer"/>) in the sense that a standard widget may not have any empty slots for content. However it&apos;s still a group of low-level canvas objects (clipper, raw objects, etc.).
  24 /// (Since EFL 1.22)</summary>
  25 [Efl.Canvas.Group.NativeMethods]
  26 public class Group : Efl.Canvas.Object, Efl.Eo.IWrapper
  27 {
  28     ///<summary>Pointer to the native class description.</summary>
  29     public override System.IntPtr NativeClass
  30     {
  31         get
  32         {
  33             if (((object)this).GetType() == typeof(Group))
  34             {
  35                 return GetEflClassStatic();
  36             }
  37             else
  38             {
  39                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  40             }
  41         }
  42     }
  43
  44     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  45         efl_canvas_group_class_get();
  46     /// <summary>Initializes a new instance of the <see cref="Group"/> class.</summary>
  47     /// <param name="parent">Parent instance.</param>
  48     public Group(Efl.Object parent= null
  49             ) : base(efl_canvas_group_class_get(), typeof(Group), parent)
  50     {
  51         FinishInstantiation();
  52     }
  53
  54     /// <summary>Initializes a new instance of the <see cref="Group"/> class.
  55     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  56     /// <param name="raw">The native pointer to be wrapped.</param>
  57     protected Group(System.IntPtr raw) : base(raw)
  58     {
  59             }
  60
  61     /// <summary>Initializes a new instance of the <see cref="Group"/> class.
  62     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  63     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  64     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  65     /// <param name="parent">The Efl.Object parent of this instance.</param>
  66     protected Group(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  67     {
  68     }
  69
  70     /// <summary>Verifies if the given object is equal to this one.</summary>
  71     /// <param name="instance">The object to compare to.</param>
  72     /// <returns>True if both objects point to the same native object.</returns>
  73     public override bool Equals(object instance)
  74     {
  75         var other = instance as Efl.Object;
  76         if (other == null)
  77         {
  78             return false;
  79         }
  80         return this.NativeHandle == other.NativeHandle;
  81     }
  82
  83     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  84     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  85     public override int GetHashCode()
  86     {
  87         return this.NativeHandle.ToInt32();
  88     }
  89
  90     /// <summary>Turns the native pointer into a string representation.</summary>
  91     /// <returns>A string with the type and the native pointer for this object.</returns>
  92     public override String ToString()
  93     {
  94         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  95     }
  96
  97     /// <summary>Called when a member is added to the group.
  98     /// (Since EFL 1.22)</summary>
  99     public event EventHandler<Efl.Canvas.GroupMemberAddedEvt_Args> MemberAddedEvt
 100     {
 101         add
 102         {
 103             lock (eventLock)
 104             {
 105                 var wRef = new WeakReference(this);
 106                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 107                 {
 108                     var obj = wRef.Target as Efl.Eo.IWrapper;
 109                     if (obj != null)
 110                     {
 111                                                 Efl.Canvas.GroupMemberAddedEvt_Args args = new Efl.Canvas.GroupMemberAddedEvt_Args();
 112                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 113                         try
 114                         {
 115                             value?.Invoke(obj, args);
 116                         }
 117                         catch (Exception e)
 118                         {
 119                             Eina.Log.Error(e.ToString());
 120                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 121                         }
 122                     }
 123                 };
 124
 125                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_ADDED";
 126                 AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
 127             }
 128         }
 129
 130         remove
 131         {
 132             lock (eventLock)
 133             {
 134                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_ADDED";
 135                 RemoveNativeEventHandler(efl.Libs.Evas, key, value);
 136             }
 137         }
 138     }
 139     ///<summary>Method to raise event MemberAddedEvt.</summary>
 140     public void OnMemberAddedEvt(Efl.Canvas.GroupMemberAddedEvt_Args e)
 141     {
 142         var key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_ADDED";
 143         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
 144         if (desc == IntPtr.Zero)
 145         {
 146             Eina.Log.Error($"Failed to get native event {key}");
 147             return;
 148         }
 149
 150         IntPtr info = e.arg.NativeHandle;
 151         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 152     }
 153     /// <summary>Called when a member is removed from the group.
 154     /// (Since EFL 1.22)</summary>
 155     public event EventHandler<Efl.Canvas.GroupMemberRemovedEvt_Args> MemberRemovedEvt
 156     {
 157         add
 158         {
 159             lock (eventLock)
 160             {
 161                 var wRef = new WeakReference(this);
 162                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 163                 {
 164                     var obj = wRef.Target as Efl.Eo.IWrapper;
 165                     if (obj != null)
 166                     {
 167                                                 Efl.Canvas.GroupMemberRemovedEvt_Args args = new Efl.Canvas.GroupMemberRemovedEvt_Args();
 168                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 169                         try
 170                         {
 171                             value?.Invoke(obj, args);
 172                         }
 173                         catch (Exception e)
 174                         {
 175                             Eina.Log.Error(e.ToString());
 176                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 177                         }
 178                     }
 179                 };
 180
 181                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_REMOVED";
 182                 AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
 183             }
 184         }
 185
 186         remove
 187         {
 188             lock (eventLock)
 189             {
 190                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_REMOVED";
 191                 RemoveNativeEventHandler(efl.Libs.Evas, key, value);
 192             }
 193         }
 194     }
 195     ///<summary>Method to raise event MemberRemovedEvt.</summary>
 196     public void OnMemberRemovedEvt(Efl.Canvas.GroupMemberRemovedEvt_Args e)
 197     {
 198         var key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_REMOVED";
 199         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
 200         if (desc == IntPtr.Zero)
 201         {
 202             Eina.Log.Error($"Failed to get native event {key}");
 203             return;
 204         }
 205
 206         IntPtr info = e.arg.NativeHandle;
 207         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 208     }
 209     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 210     /// If this flag is set, then the <see cref="Efl.Canvas.Group.CalculateGroup"/> function will be called, during rendering phase of the canvas. After that, this flag will be automatically unset.
 211     ///
 212     /// Note: setting this flag alone will not make the canvas&apos; whole scene dirty. Using evas_render() will have no effect. To force this, use <see cref="Efl.Canvas.Group.GroupChange"/>, which will also call this function automatically, with the parameter set to <c>true</c>.
 213     ///
 214     /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 215     /// (Since EFL 1.22)</summary>
 216     /// <returns><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</returns>
 217     virtual public bool GetGroupNeedRecalculate() {
 218          var _ret_var = Efl.Canvas.Group.NativeMethods.efl_canvas_group_need_recalculate_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 219         Eina.Error.RaiseIfUnhandledException();
 220         return _ret_var;
 221  }
 222     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 223     /// If this flag is set, then the <see cref="Efl.Canvas.Group.CalculateGroup"/> function will be called, during rendering phase of the canvas. After that, this flag will be automatically unset.
 224     ///
 225     /// Note: setting this flag alone will not make the canvas&apos; whole scene dirty. Using evas_render() will have no effect. To force this, use <see cref="Efl.Canvas.Group.GroupChange"/>, which will also call this function automatically, with the parameter set to <c>true</c>.
 226     ///
 227     /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 228     /// (Since EFL 1.22)</summary>
 229     /// <param name="value"><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</param>
 230     virtual public void SetGroupNeedRecalculate(bool value) {
 231                                  Efl.Canvas.Group.NativeMethods.efl_canvas_group_need_recalculate_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 232         Eina.Error.RaiseIfUnhandledException();
 233                          }
 234     /// <summary>Get the internal clipper.
 235     /// (Since EFL 1.22)</summary>
 236     /// <returns>A clipper rectangle.</returns>
 237     virtual public Efl.Canvas.Object GetGroupClipper() {
 238          var _ret_var = Efl.Canvas.Group.NativeMethods.efl_canvas_group_clipper_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 239         Eina.Error.RaiseIfUnhandledException();
 240         return _ret_var;
 241  }
 242     /// <summary>Marks the object as dirty.
 243     /// This also forcefully marks the given object as needing recalculation. As an effect, on the next rendering cycle its <see cref="Efl.Canvas.Group.CalculateGroup"/> method will be called.
 244     /// (Since EFL 1.22)</summary>
 245     virtual public void GroupChange() {
 246          Efl.Canvas.Group.NativeMethods.efl_canvas_group_change_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 247         Eina.Error.RaiseIfUnhandledException();
 248          }
 249     /// <summary>Triggers an immediate recalculation of this object&apos;s geometry.
 250     /// This will also reset the flag <see cref="Efl.Canvas.Group.GroupNeedRecalculate"/>.
 251     /// (Since EFL 1.22)</summary>
 252     virtual public void CalculateGroup() {
 253          Efl.Canvas.Group.NativeMethods.efl_canvas_group_calculate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 254         Eina.Error.RaiseIfUnhandledException();
 255          }
 256     /// <summary>Returns an iterator over the children of this object, which are canvas objects.
 257     /// This returns the list of &quot;smart&quot; children. This might be different from both the <see cref="Efl.Object"/> children list as well as the <see cref="Efl.IContainer"/> content list.
 258     /// (Since EFL 1.22)</summary>
 259     /// <returns>Iterator to object children</returns>
 260     virtual public Eina.Iterator<Efl.Canvas.Object> GroupMembersIterate() {
 261          var _ret_var = Efl.Canvas.Group.NativeMethods.efl_canvas_group_members_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 262         Eina.Error.RaiseIfUnhandledException();
 263         return new Eina.Iterator<Efl.Canvas.Object>(_ret_var, true, false);
 264  }
 265     /// <summary>Set a canvas object as a member of a given group (or smart object).
 266     /// Members will automatically be stacked and layered together with the smart object. The various stacking functions will operate on members relative to the other members instead of the entire canvas, since they now live on an exclusive layer (see <see cref="Efl.Gfx.IStack.StackAbove"/>, for more details).
 267     ///
 268     /// Subclasses inheriting from this one may override this function to ensure the proper stacking of special objects, such as clippers, event rectangles, etc...
 269     ///
 270     /// See also <see cref="Efl.Canvas.Group.GroupMemberRemove"/>. See also <see cref="Efl.Canvas.Group.IsGroupMember"/>.
 271     /// (Since EFL 1.22)</summary>
 272     /// <param name="sub_obj">The member object.</param>
 273     virtual public void AddGroupMember(Efl.Canvas.Object sub_obj) {
 274                                  Efl.Canvas.Group.NativeMethods.efl_canvas_group_member_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sub_obj);
 275         Eina.Error.RaiseIfUnhandledException();
 276                          }
 277     /// <summary>Removes a member object from a given smart object.
 278     /// This removes a member object from a smart object, if it was added to any. The object will still be on the canvas, but no longer associated with whichever smart object it was associated with.
 279     ///
 280     /// See also <see cref="Efl.Canvas.Group.AddGroupMember"/>. See also <see cref="Efl.Canvas.Group.IsGroupMember"/>.
 281     /// (Since EFL 1.22)</summary>
 282     /// <param name="sub_obj">The member object to remove.</param>
 283     virtual public void GroupMemberRemove(Efl.Canvas.Object sub_obj) {
 284                                  Efl.Canvas.Group.NativeMethods.efl_canvas_group_member_remove_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sub_obj);
 285         Eina.Error.RaiseIfUnhandledException();
 286                          }
 287     /// <summary>Finds out if a given object is a member of this group.
 288     /// (Since EFL 1.22)</summary>
 289     /// <param name="sub_obj">A potential sub object.</param>
 290     /// <returns><c>true</c> if <c>sub_obj</c> is a member of this group.</returns>
 291     virtual public bool IsGroupMember(Efl.Canvas.Object sub_obj) {
 292                                  var _ret_var = Efl.Canvas.Group.NativeMethods.efl_canvas_group_member_is_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sub_obj);
 293         Eina.Error.RaiseIfUnhandledException();
 294                         return _ret_var;
 295  }
 296     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 297 /// If this flag is set, then the <see cref="Efl.Canvas.Group.CalculateGroup"/> function will be called, during rendering phase of the canvas. After that, this flag will be automatically unset.
 298 ///
 299 /// Note: setting this flag alone will not make the canvas&apos; whole scene dirty. Using evas_render() will have no effect. To force this, use <see cref="Efl.Canvas.Group.GroupChange"/>, which will also call this function automatically, with the parameter set to <c>true</c>.
 300 ///
 301 /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 302 /// (Since EFL 1.22)</summary>
 303 /// <value><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</value>
 304     public bool GroupNeedRecalculate {
 305         get { return GetGroupNeedRecalculate(); }
 306         set { SetGroupNeedRecalculate(value); }
 307     }
 308     /// <summary>The internal clipper object used by this group.
 309 /// This is the object clipping all the child objects. Do not delete or otherwise modify this clipper!
 310 /// (Since EFL 1.22)</summary>
 311 /// <value>A clipper rectangle.</value>
 312     public Efl.Canvas.Object GroupClipper {
 313         get { return GetGroupClipper(); }
 314     }
 315     private static IntPtr GetEflClassStatic()
 316     {
 317         return Efl.Canvas.Group.efl_canvas_group_class_get();
 318     }
 319     /// <summary>Wrapper for native methods and virtual method delegates.
 320     /// For internal use by generated code only.</summary>
 321     public new class NativeMethods : Efl.Canvas.Object.NativeMethods
 322     {
 323         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 324         /// <summary>Gets the list of Eo operations to override.</summary>
 325         /// <returns>The list of Eo operations to be overload.</returns>
 326         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 327         {
 328             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 329             var methods = Efl.Eo.Globals.GetUserMethods(type);
 330
 331             if (efl_canvas_group_need_recalculate_get_static_delegate == null)
 332             {
 333                 efl_canvas_group_need_recalculate_get_static_delegate = new efl_canvas_group_need_recalculate_get_delegate(group_need_recalculate_get);
 334             }
 335
 336             if (methods.FirstOrDefault(m => m.Name == "GetGroupNeedRecalculate") != null)
 337             {
 338                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_need_recalculate_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_need_recalculate_get_static_delegate) });
 339             }
 340
 341             if (efl_canvas_group_need_recalculate_set_static_delegate == null)
 342             {
 343                 efl_canvas_group_need_recalculate_set_static_delegate = new efl_canvas_group_need_recalculate_set_delegate(group_need_recalculate_set);
 344             }
 345
 346             if (methods.FirstOrDefault(m => m.Name == "SetGroupNeedRecalculate") != null)
 347             {
 348                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_need_recalculate_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_need_recalculate_set_static_delegate) });
 349             }
 350
 351             if (efl_canvas_group_clipper_get_static_delegate == null)
 352             {
 353                 efl_canvas_group_clipper_get_static_delegate = new efl_canvas_group_clipper_get_delegate(group_clipper_get);
 354             }
 355
 356             if (methods.FirstOrDefault(m => m.Name == "GetGroupClipper") != null)
 357             {
 358                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_clipper_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_clipper_get_static_delegate) });
 359             }
 360
 361             if (efl_canvas_group_change_static_delegate == null)
 362             {
 363                 efl_canvas_group_change_static_delegate = new efl_canvas_group_change_delegate(group_change);
 364             }
 365
 366             if (methods.FirstOrDefault(m => m.Name == "GroupChange") != null)
 367             {
 368                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_change"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_change_static_delegate) });
 369             }
 370
 371             if (efl_canvas_group_calculate_static_delegate == null)
 372             {
 373                 efl_canvas_group_calculate_static_delegate = new efl_canvas_group_calculate_delegate(group_calculate);
 374             }
 375
 376             if (methods.FirstOrDefault(m => m.Name == "CalculateGroup") != null)
 377             {
 378                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_calculate"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_calculate_static_delegate) });
 379             }
 380
 381             if (efl_canvas_group_members_iterate_static_delegate == null)
 382             {
 383                 efl_canvas_group_members_iterate_static_delegate = new efl_canvas_group_members_iterate_delegate(group_members_iterate);
 384             }
 385
 386             if (methods.FirstOrDefault(m => m.Name == "GroupMembersIterate") != null)
 387             {
 388                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_members_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_members_iterate_static_delegate) });
 389             }
 390
 391             if (efl_canvas_group_member_add_static_delegate == null)
 392             {
 393                 efl_canvas_group_member_add_static_delegate = new efl_canvas_group_member_add_delegate(group_member_add);
 394             }
 395
 396             if (methods.FirstOrDefault(m => m.Name == "AddGroupMember") != null)
 397             {
 398                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_member_add"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_member_add_static_delegate) });
 399             }
 400
 401             if (efl_canvas_group_member_remove_static_delegate == null)
 402             {
 403                 efl_canvas_group_member_remove_static_delegate = new efl_canvas_group_member_remove_delegate(group_member_remove);
 404             }
 405
 406             if (methods.FirstOrDefault(m => m.Name == "GroupMemberRemove") != null)
 407             {
 408                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_member_remove"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_member_remove_static_delegate) });
 409             }
 410
 411             if (efl_canvas_group_member_is_static_delegate == null)
 412             {
 413                 efl_canvas_group_member_is_static_delegate = new efl_canvas_group_member_is_delegate(group_member_is);
 414             }
 415
 416             if (methods.FirstOrDefault(m => m.Name == "IsGroupMember") != null)
 417             {
 418                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_group_member_is"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_group_member_is_static_delegate) });
 419             }
 420
 421             descs.AddRange(base.GetEoOps(type));
 422             return descs;
 423         }
 424         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 425         /// <returns>The native class pointer.</returns>
 426         public override IntPtr GetEflClass()
 427         {
 428             return Efl.Canvas.Group.efl_canvas_group_class_get();
 429         }
 430
 431         #pragma warning disable CA1707, SA1300, SA1600
 432
 433         [return: MarshalAs(UnmanagedType.U1)]
 434         private delegate bool efl_canvas_group_need_recalculate_get_delegate(System.IntPtr obj, System.IntPtr pd);
 435
 436         [return: MarshalAs(UnmanagedType.U1)]
 437         public delegate bool efl_canvas_group_need_recalculate_get_api_delegate(System.IntPtr obj);
 438
 439         public static Efl.Eo.FunctionWrapper<efl_canvas_group_need_recalculate_get_api_delegate> efl_canvas_group_need_recalculate_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_need_recalculate_get_api_delegate>(Module, "efl_canvas_group_need_recalculate_get");
 440
 441         private static bool group_need_recalculate_get(System.IntPtr obj, System.IntPtr pd)
 442         {
 443             Eina.Log.Debug("function efl_canvas_group_need_recalculate_get was called");
 444             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 445             if (wrapper != null)
 446             {
 447             bool _ret_var = default(bool);
 448                 try
 449                 {
 450                     _ret_var = ((Group)wrapper).GetGroupNeedRecalculate();
 451                 }
 452                 catch (Exception e)
 453                 {
 454                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 455                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 456                 }
 457
 458         return _ret_var;
 459
 460             }
 461             else
 462             {
 463                 return efl_canvas_group_need_recalculate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 464             }
 465         }
 466
 467         private static efl_canvas_group_need_recalculate_get_delegate efl_canvas_group_need_recalculate_get_static_delegate;
 468
 469
 470         private delegate void efl_canvas_group_need_recalculate_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool value);
 471
 472
 473         public delegate void efl_canvas_group_need_recalculate_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool value);
 474
 475         public static Efl.Eo.FunctionWrapper<efl_canvas_group_need_recalculate_set_api_delegate> efl_canvas_group_need_recalculate_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_need_recalculate_set_api_delegate>(Module, "efl_canvas_group_need_recalculate_set");
 476
 477         private static void group_need_recalculate_set(System.IntPtr obj, System.IntPtr pd, bool value)
 478         {
 479             Eina.Log.Debug("function efl_canvas_group_need_recalculate_set was called");
 480             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 481             if (wrapper != null)
 482             {
 483
 484                 try
 485                 {
 486                     ((Group)wrapper).SetGroupNeedRecalculate(value);
 487                 }
 488                 catch (Exception e)
 489                 {
 490                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 491                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 492                 }
 493
 494
 495             }
 496             else
 497             {
 498                 efl_canvas_group_need_recalculate_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
 499             }
 500         }
 501
 502         private static efl_canvas_group_need_recalculate_set_delegate efl_canvas_group_need_recalculate_set_static_delegate;
 503
 504         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 505         private delegate Efl.Canvas.Object efl_canvas_group_clipper_get_delegate(System.IntPtr obj, System.IntPtr pd);
 506
 507         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 508         public delegate Efl.Canvas.Object efl_canvas_group_clipper_get_api_delegate(System.IntPtr obj);
 509
 510         public static Efl.Eo.FunctionWrapper<efl_canvas_group_clipper_get_api_delegate> efl_canvas_group_clipper_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_clipper_get_api_delegate>(Module, "efl_canvas_group_clipper_get");
 511
 512         private static Efl.Canvas.Object group_clipper_get(System.IntPtr obj, System.IntPtr pd)
 513         {
 514             Eina.Log.Debug("function efl_canvas_group_clipper_get was called");
 515             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 516             if (wrapper != null)
 517             {
 518             Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
 519                 try
 520                 {
 521                     _ret_var = ((Group)wrapper).GetGroupClipper();
 522                 }
 523                 catch (Exception e)
 524                 {
 525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 527                 }
 528
 529         return _ret_var;
 530
 531             }
 532             else
 533             {
 534                 return efl_canvas_group_clipper_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 535             }
 536         }
 537
 538         private static efl_canvas_group_clipper_get_delegate efl_canvas_group_clipper_get_static_delegate;
 539
 540
 541         private delegate void efl_canvas_group_change_delegate(System.IntPtr obj, System.IntPtr pd);
 542
 543
 544         public delegate void efl_canvas_group_change_api_delegate(System.IntPtr obj);
 545
 546         public static Efl.Eo.FunctionWrapper<efl_canvas_group_change_api_delegate> efl_canvas_group_change_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_change_api_delegate>(Module, "efl_canvas_group_change");
 547
 548         private static void group_change(System.IntPtr obj, System.IntPtr pd)
 549         {
 550             Eina.Log.Debug("function efl_canvas_group_change was called");
 551             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 552             if (wrapper != null)
 553             {
 554
 555                 try
 556                 {
 557                     ((Group)wrapper).GroupChange();
 558                 }
 559                 catch (Exception e)
 560                 {
 561                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 562                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 563                 }
 564
 565
 566             }
 567             else
 568             {
 569                 efl_canvas_group_change_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 570             }
 571         }
 572
 573         private static efl_canvas_group_change_delegate efl_canvas_group_change_static_delegate;
 574
 575
 576         private delegate void efl_canvas_group_calculate_delegate(System.IntPtr obj, System.IntPtr pd);
 577
 578
 579         public delegate void efl_canvas_group_calculate_api_delegate(System.IntPtr obj);
 580
 581         public static Efl.Eo.FunctionWrapper<efl_canvas_group_calculate_api_delegate> efl_canvas_group_calculate_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_calculate_api_delegate>(Module, "efl_canvas_group_calculate");
 582
 583         private static void group_calculate(System.IntPtr obj, System.IntPtr pd)
 584         {
 585             Eina.Log.Debug("function efl_canvas_group_calculate was called");
 586             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 587             if (wrapper != null)
 588             {
 589
 590                 try
 591                 {
 592                     ((Group)wrapper).CalculateGroup();
 593                 }
 594                 catch (Exception e)
 595                 {
 596                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 597                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598                 }
 599
 600
 601             }
 602             else
 603             {
 604                 efl_canvas_group_calculate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 605             }
 606         }
 607
 608         private static efl_canvas_group_calculate_delegate efl_canvas_group_calculate_static_delegate;
 609
 610
 611         private delegate System.IntPtr efl_canvas_group_members_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 612
 613
 614         public delegate System.IntPtr efl_canvas_group_members_iterate_api_delegate(System.IntPtr obj);
 615
 616         public static Efl.Eo.FunctionWrapper<efl_canvas_group_members_iterate_api_delegate> efl_canvas_group_members_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_members_iterate_api_delegate>(Module, "efl_canvas_group_members_iterate");
 617
 618         private static System.IntPtr group_members_iterate(System.IntPtr obj, System.IntPtr pd)
 619         {
 620             Eina.Log.Debug("function efl_canvas_group_members_iterate was called");
 621             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 622             if (wrapper != null)
 623             {
 624             Eina.Iterator<Efl.Canvas.Object> _ret_var = default(Eina.Iterator<Efl.Canvas.Object>);
 625                 try
 626                 {
 627                     _ret_var = ((Group)wrapper).GroupMembersIterate();
 628                 }
 629                 catch (Exception e)
 630                 {
 631                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 632                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 633                 }
 634
 635         _ret_var.Own = false; return _ret_var.Handle;
 636
 637             }
 638             else
 639             {
 640                 return efl_canvas_group_members_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 641             }
 642         }
 643
 644         private static efl_canvas_group_members_iterate_delegate efl_canvas_group_members_iterate_static_delegate;
 645
 646
 647         private delegate void efl_canvas_group_member_add_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 648
 649
 650         public delegate void efl_canvas_group_member_add_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 651
 652         public static Efl.Eo.FunctionWrapper<efl_canvas_group_member_add_api_delegate> efl_canvas_group_member_add_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_member_add_api_delegate>(Module, "efl_canvas_group_member_add");
 653
 654         private static void group_member_add(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object sub_obj)
 655         {
 656             Eina.Log.Debug("function efl_canvas_group_member_add was called");
 657             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 658             if (wrapper != null)
 659             {
 660
 661                 try
 662                 {
 663                     ((Group)wrapper).AddGroupMember(sub_obj);
 664                 }
 665                 catch (Exception e)
 666                 {
 667                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 668                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 669                 }
 670
 671
 672             }
 673             else
 674             {
 675                 efl_canvas_group_member_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sub_obj);
 676             }
 677         }
 678
 679         private static efl_canvas_group_member_add_delegate efl_canvas_group_member_add_static_delegate;
 680
 681
 682         private delegate void efl_canvas_group_member_remove_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 683
 684
 685         public delegate void efl_canvas_group_member_remove_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 686
 687         public static Efl.Eo.FunctionWrapper<efl_canvas_group_member_remove_api_delegate> efl_canvas_group_member_remove_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_member_remove_api_delegate>(Module, "efl_canvas_group_member_remove");
 688
 689         private static void group_member_remove(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object sub_obj)
 690         {
 691             Eina.Log.Debug("function efl_canvas_group_member_remove was called");
 692             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 693             if (wrapper != null)
 694             {
 695
 696                 try
 697                 {
 698                     ((Group)wrapper).GroupMemberRemove(sub_obj);
 699                 }
 700                 catch (Exception e)
 701                 {
 702                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 703                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 704                 }
 705
 706
 707             }
 708             else
 709             {
 710                 efl_canvas_group_member_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sub_obj);
 711             }
 712         }
 713
 714         private static efl_canvas_group_member_remove_delegate efl_canvas_group_member_remove_static_delegate;
 715
 716         [return: MarshalAs(UnmanagedType.U1)]
 717         private delegate bool efl_canvas_group_member_is_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 718
 719         [return: MarshalAs(UnmanagedType.U1)]
 720         public delegate bool efl_canvas_group_member_is_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object sub_obj);
 721
 722         public static Efl.Eo.FunctionWrapper<efl_canvas_group_member_is_api_delegate> efl_canvas_group_member_is_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_group_member_is_api_delegate>(Module, "efl_canvas_group_member_is");
 723
 724         private static bool group_member_is(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object sub_obj)
 725         {
 726             Eina.Log.Debug("function efl_canvas_group_member_is was called");
 727             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 728             if (wrapper != null)
 729             {
 730                                     bool _ret_var = default(bool);
 731                 try
 732                 {
 733                     _ret_var = ((Group)wrapper).IsGroupMember(sub_obj);
 734                 }
 735                 catch (Exception e)
 736                 {
 737                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 738                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 739                 }
 740
 741                         return _ret_var;
 742
 743             }
 744             else
 745             {
 746                 return efl_canvas_group_member_is_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sub_obj);
 747             }
 748         }
 749
 750         private static efl_canvas_group_member_is_delegate efl_canvas_group_member_is_static_delegate;
 751
 752         #pragma warning restore CA1707, SA1300, SA1600
 753
 754 }
 755 }
 756 }
 757
 758 }
 759