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

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