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