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.ComponentModel;
   7 namespace Efl { namespace Canvas {
   8 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.Group.MemberAddedEvt"/>.</summary>
   9 public class GroupMemberAddedEvt_Args : EventArgs {
  10     ///<summary>Actual event payload.</summary>
  11     public Efl.Gfx.IEntity arg { get; set; }
  12 }
  13 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.Group.MemberRemovedEvt"/>.</summary>
  14 public class GroupMemberRemovedEvt_Args : EventArgs {
  15     ///<summary>Actual event payload.</summary>
  16     public Efl.Gfx.IEntity arg { get; set; }
  17 }
  18 /// <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.
  19 /// 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.).
  20 /// (Since EFL 1.22)</summary>
  21 [GroupNativeInherit]
  22 public class Group : Efl.Canvas.Object, Efl.Eo.IWrapper
  23 {
  24     ///<summary>Pointer to the native class description.</summary>
  25     public override System.IntPtr NativeClass {
  26         get {
  27             if (((object)this).GetType() == typeof (Group))
  28                 return Efl.Canvas.GroupNativeInherit.GetEflClassStatic();
  29             else
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31         }
  32     }
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  34         efl_canvas_group_class_get();
  35     ///<summary>Creates a new instance.</summary>
  36     ///<param name="parent">Parent instance.</param>
  37     public Group(Efl.Object parent= null
  38             ) :
  39         base(efl_canvas_group_class_get(), typeof(Group), parent)
  40     {
  41         FinishInstantiation();
  42     }
  43     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  44     protected Group(System.IntPtr raw) : base(raw)
  45     {
  46                 RegisterEventProxies();
  47     }
  48     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  49     protected Group(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  50     ///<summary>Verifies if the given object is equal to this one.</summary>
  51     public override bool Equals(object obj)
  52     {
  53         var other = obj as Efl.Object;
  54         if (other == null)
  55             return false;
  56         return this.NativeHandle == other.NativeHandle;
  57     }
  58     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  59     public override int GetHashCode()
  60     {
  61         return this.NativeHandle.ToInt32();
  62     }
  63     ///<summary>Turns the native pointer into a string representation.</summary>
  64     public override String ToString()
  65     {
  66         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  67     }
  68 private static object MemberAddedEvtKey = new object();
  69     /// <summary>Called when a member is added to the group.
  70     /// (Since EFL 1.22)</summary>
  71     public event EventHandler<Efl.Canvas.GroupMemberAddedEvt_Args> MemberAddedEvt
  72     {
  73         add {
  74             lock (eventLock) {
  75                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_ADDED";
  76                 if (AddNativeEventHandler(efl.Libs.Evas, key, this.evt_MemberAddedEvt_delegate)) {
  77                     eventHandlers.AddHandler(MemberAddedEvtKey , value);
  78                 } else
  79                     Eina.Log.Error($"Error adding proxy for event {key}");
  80             }
  81         }
  82         remove {
  83             lock (eventLock) {
  84                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_ADDED";
  85                 if (RemoveNativeEventHandler(key, this.evt_MemberAddedEvt_delegate)) {
  86                     eventHandlers.RemoveHandler(MemberAddedEvtKey , value);
  87                 } else
  88                     Eina.Log.Error($"Error removing proxy for event {key}");
  89             }
  90         }
  91     }
  92     ///<summary>Method to raise event MemberAddedEvt.</summary>
  93     public void On_MemberAddedEvt(Efl.Canvas.GroupMemberAddedEvt_Args e)
  94     {
  95         EventHandler<Efl.Canvas.GroupMemberAddedEvt_Args> evt;
  96         lock (eventLock) {
  97         evt = (EventHandler<Efl.Canvas.GroupMemberAddedEvt_Args>)eventHandlers[MemberAddedEvtKey];
  98         }
  99         evt?.Invoke(this, e);
 100     }
 101     Efl.EventCb evt_MemberAddedEvt_delegate;
 102     private void on_MemberAddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 103     {
 104         Efl.Canvas.GroupMemberAddedEvt_Args args = new Efl.Canvas.GroupMemberAddedEvt_Args();
 105       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 106         try {
 107             On_MemberAddedEvt(args);
 108         } catch (Exception e) {
 109             Eina.Log.Error(e.ToString());
 110             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 111         }
 112     }
 113
 114 private static object MemberRemovedEvtKey = new object();
 115     /// <summary>Called when a member is removed from the group.
 116     /// (Since EFL 1.22)</summary>
 117     public event EventHandler<Efl.Canvas.GroupMemberRemovedEvt_Args> MemberRemovedEvt
 118     {
 119         add {
 120             lock (eventLock) {
 121                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_REMOVED";
 122                 if (AddNativeEventHandler(efl.Libs.Evas, key, this.evt_MemberRemovedEvt_delegate)) {
 123                     eventHandlers.AddHandler(MemberRemovedEvtKey , value);
 124                 } else
 125                     Eina.Log.Error($"Error adding proxy for event {key}");
 126             }
 127         }
 128         remove {
 129             lock (eventLock) {
 130                 string key = "_EFL_CANVAS_GROUP_EVENT_MEMBER_REMOVED";
 131                 if (RemoveNativeEventHandler(key, this.evt_MemberRemovedEvt_delegate)) {
 132                     eventHandlers.RemoveHandler(MemberRemovedEvtKey , value);
 133                 } else
 134                     Eina.Log.Error($"Error removing proxy for event {key}");
 135             }
 136         }
 137     }
 138     ///<summary>Method to raise event MemberRemovedEvt.</summary>
 139     public void On_MemberRemovedEvt(Efl.Canvas.GroupMemberRemovedEvt_Args e)
 140     {
 141         EventHandler<Efl.Canvas.GroupMemberRemovedEvt_Args> evt;
 142         lock (eventLock) {
 143         evt = (EventHandler<Efl.Canvas.GroupMemberRemovedEvt_Args>)eventHandlers[MemberRemovedEvtKey];
 144         }
 145         evt?.Invoke(this, e);
 146     }
 147     Efl.EventCb evt_MemberRemovedEvt_delegate;
 148     private void on_MemberRemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 149     {
 150         Efl.Canvas.GroupMemberRemovedEvt_Args args = new Efl.Canvas.GroupMemberRemovedEvt_Args();
 151       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 152         try {
 153             On_MemberRemovedEvt(args);
 154         } catch (Exception e) {
 155             Eina.Log.Error(e.ToString());
 156             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 157         }
 158     }
 159
 160     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 161     protected override void RegisterEventProxies()
 162     {
 163         base.RegisterEventProxies();
 164         evt_MemberAddedEvt_delegate = new Efl.EventCb(on_MemberAddedEvt_NativeCallback);
 165         evt_MemberRemovedEvt_delegate = new Efl.EventCb(on_MemberRemovedEvt_NativeCallback);
 166     }
 167     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 168     /// 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.
 169     ///
 170     /// 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>.
 171     ///
 172     /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 173     /// (Since EFL 1.22)</summary>
 174     /// <returns><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</returns>
 175     virtual public bool GetGroupNeedRecalculate() {
 176          var _ret_var = Efl.Canvas.GroupNativeInherit.efl_canvas_group_need_recalculate_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 177         Eina.Error.RaiseIfUnhandledException();
 178         return _ret_var;
 179  }
 180     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 181     /// 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.
 182     ///
 183     /// 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>.
 184     ///
 185     /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 186     /// (Since EFL 1.22)</summary>
 187     /// <param name="value"><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</param>
 188     /// <returns></returns>
 189     virtual public void SetGroupNeedRecalculate( bool value) {
 190                                  Efl.Canvas.GroupNativeInherit.efl_canvas_group_need_recalculate_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), value);
 191         Eina.Error.RaiseIfUnhandledException();
 192                          }
 193     /// <summary>Get the internal clipper.
 194     /// (Since EFL 1.22)</summary>
 195     /// <returns>A clipper rectangle.</returns>
 196     virtual public Efl.Canvas.Object GetGroupClipper() {
 197          var _ret_var = Efl.Canvas.GroupNativeInherit.efl_canvas_group_clipper_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 198         Eina.Error.RaiseIfUnhandledException();
 199         return _ret_var;
 200  }
 201     /// <summary>Marks the object as dirty.
 202     /// 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.
 203     /// (Since EFL 1.22)</summary>
 204     /// <returns></returns>
 205     virtual public void GroupChange() {
 206          Efl.Canvas.GroupNativeInherit.efl_canvas_group_change_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 207         Eina.Error.RaiseIfUnhandledException();
 208          }
 209     /// <summary>Triggers an immediate recalculation of this object&apos;s geometry.
 210     /// This will also reset the flag <see cref="Efl.Canvas.Group.GroupNeedRecalculate"/>.
 211     /// (Since EFL 1.22)</summary>
 212     /// <returns></returns>
 213     virtual public void CalculateGroup() {
 214          Efl.Canvas.GroupNativeInherit.efl_canvas_group_calculate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 215         Eina.Error.RaiseIfUnhandledException();
 216          }
 217     /// <summary>Returns an iterator over the children of this object, which are canvas objects.
 218     /// 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.
 219     /// (Since EFL 1.22)</summary>
 220     /// <returns>Iterator to object children</returns>
 221     virtual public Eina.Iterator<Efl.Canvas.Object> GroupMembersIterate() {
 222          var _ret_var = Efl.Canvas.GroupNativeInherit.efl_canvas_group_members_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 223         Eina.Error.RaiseIfUnhandledException();
 224         return new Eina.Iterator<Efl.Canvas.Object>(_ret_var, true, false);
 225  }
 226     /// <summary>Set a canvas object as a member of a given group (or smart object).
 227     /// 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).
 228     ///
 229     /// Subclasses inheriting from this one may override this function to ensure the proper stacking of special objects, such as clippers, event rectangles, etc...
 230     ///
 231     /// See also <see cref="Efl.Canvas.Group.GroupMemberRemove"/>. See also <see cref="Efl.Canvas.Group.IsGroupMember"/>.
 232     /// (Since EFL 1.22)</summary>
 233     /// <param name="sub_obj">The member object.</param>
 234     /// <returns></returns>
 235     virtual public void AddGroupMember( Efl.Canvas.Object sub_obj) {
 236                                  Efl.Canvas.GroupNativeInherit.efl_canvas_group_member_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sub_obj);
 237         Eina.Error.RaiseIfUnhandledException();
 238                          }
 239     /// <summary>Removes a member object from a given smart object.
 240     /// 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.
 241     ///
 242     /// See also <see cref="Efl.Canvas.Group.AddGroupMember"/>. See also <see cref="Efl.Canvas.Group.IsGroupMember"/>.
 243     /// (Since EFL 1.22)</summary>
 244     /// <param name="sub_obj">The member object to remove.</param>
 245     /// <returns></returns>
 246     virtual public void GroupMemberRemove( Efl.Canvas.Object sub_obj) {
 247                                  Efl.Canvas.GroupNativeInherit.efl_canvas_group_member_remove_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sub_obj);
 248         Eina.Error.RaiseIfUnhandledException();
 249                          }
 250     /// <summary>Finds out if a given object is a member of this group.
 251     /// (Since EFL 1.22)</summary>
 252     /// <param name="sub_obj">A potential sub object.</param>
 253     /// <returns><c>true</c> if <c>sub_obj</c> is a member of this group.</returns>
 254     virtual public bool IsGroupMember( Efl.Canvas.Object sub_obj) {
 255                                  var _ret_var = Efl.Canvas.GroupNativeInherit.efl_canvas_group_member_is_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sub_obj);
 256         Eina.Error.RaiseIfUnhandledException();
 257                         return _ret_var;
 258  }
 259     /// <summary>Indicates that the group&apos;s layout needs to be recalculated.
 260 /// 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.
 261 ///
 262 /// 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>.
 263 ///
 264 /// See also <see cref="Efl.Canvas.Group.CalculateGroup"/>.
 265 /// (Since EFL 1.22)</summary>
 266 /// <value><c>true</c> if the group layout needs to be recalculated, <c>false</c> otherwise</value>
 267     public bool GroupNeedRecalculate {
 268         get { return GetGroupNeedRecalculate(); }
 269         set { SetGroupNeedRecalculate( value); }
 270     }
 271     /// <summary>The internal clipper object used by this group.
 272 /// This is the object clipping all the child objects. Do not delete or otherwise modify this clipper!
 273 /// (Since EFL 1.22)</summary>
 274 /// <value>A clipper rectangle.</value>
 275     public Efl.Canvas.Object GroupClipper {
 276         get { return GetGroupClipper(); }
 277     }
 278     private static IntPtr GetEflClassStatic()
 279     {
 280         return Efl.Canvas.Group.efl_canvas_group_class_get();
 281     }
 282 }
 283 public class GroupNativeInherit : Efl.Canvas.ObjectNativeInherit{
 284     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Evas);
 285     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 286     {
 287         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 288         var methods = Efl.Eo.Globals.GetUserMethods(type);
 289         if (efl_canvas_group_need_recalculate_get_static_delegate == null)
 290             efl_canvas_group_need_recalculate_get_static_delegate = new efl_canvas_group_need_recalculate_get_delegate(group_need_recalculate_get);
 291         if (methods.FirstOrDefault(m => m.Name == "GetGroupNeedRecalculate") != null)
 292             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)});
 293         if (efl_canvas_group_need_recalculate_set_static_delegate == null)
 294             efl_canvas_group_need_recalculate_set_static_delegate = new efl_canvas_group_need_recalculate_set_delegate(group_need_recalculate_set);
 295         if (methods.FirstOrDefault(m => m.Name == "SetGroupNeedRecalculate") != null)
 296             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)});
 297         if (efl_canvas_group_clipper_get_static_delegate == null)
 298             efl_canvas_group_clipper_get_static_delegate = new efl_canvas_group_clipper_get_delegate(group_clipper_get);
 299         if (methods.FirstOrDefault(m => m.Name == "GetGroupClipper") != null)
 300             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)});
 301         if (efl_canvas_group_change_static_delegate == null)
 302             efl_canvas_group_change_static_delegate = new efl_canvas_group_change_delegate(group_change);
 303         if (methods.FirstOrDefault(m => m.Name == "GroupChange") != null)
 304             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)});
 305         if (efl_canvas_group_calculate_static_delegate == null)
 306             efl_canvas_group_calculate_static_delegate = new efl_canvas_group_calculate_delegate(group_calculate);
 307         if (methods.FirstOrDefault(m => m.Name == "CalculateGroup") != null)
 308             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)});
 309         if (efl_canvas_group_members_iterate_static_delegate == null)
 310             efl_canvas_group_members_iterate_static_delegate = new efl_canvas_group_members_iterate_delegate(group_members_iterate);
 311         if (methods.FirstOrDefault(m => m.Name == "GroupMembersIterate") != null)
 312             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)});
 313         if (efl_canvas_group_member_add_static_delegate == null)
 314             efl_canvas_group_member_add_static_delegate = new efl_canvas_group_member_add_delegate(group_member_add);
 315         if (methods.FirstOrDefault(m => m.Name == "AddGroupMember") != null)
 316             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)});
 317         if (efl_canvas_group_member_remove_static_delegate == null)
 318             efl_canvas_group_member_remove_static_delegate = new efl_canvas_group_member_remove_delegate(group_member_remove);
 319         if (methods.FirstOrDefault(m => m.Name == "GroupMemberRemove") != null)
 320             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)});
 321         if (efl_canvas_group_member_is_static_delegate == null)
 322             efl_canvas_group_member_is_static_delegate = new efl_canvas_group_member_is_delegate(group_member_is);
 323         if (methods.FirstOrDefault(m => m.Name == "IsGroupMember") != null)
 324             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)});
 325         descs.AddRange(base.GetEoOps(type));
 326         return descs;
 327     }
 328     public override IntPtr GetEflClass()
 329     {
 330         return Efl.Canvas.Group.efl_canvas_group_class_get();
 331     }
 332     public static new  IntPtr GetEflClassStatic()
 333     {
 334         return Efl.Canvas.Group.efl_canvas_group_class_get();
 335     }
 336
 337
 338      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_group_need_recalculate_get_delegate(System.IntPtr obj, System.IntPtr pd);
 339
 340
 341      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_group_need_recalculate_get_api_delegate(System.IntPtr obj);
 342      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");
 343      private static bool group_need_recalculate_get(System.IntPtr obj, System.IntPtr pd)
 344     {
 345         Eina.Log.Debug("function efl_canvas_group_need_recalculate_get was called");
 346         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 347         if(wrapper != null) {
 348                         bool _ret_var = default(bool);
 349             try {
 350                 _ret_var = ((Group)wrapper).GetGroupNeedRecalculate();
 351             } catch (Exception e) {
 352                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 353                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 354             }
 355         return _ret_var;
 356         } else {
 357             return efl_canvas_group_need_recalculate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 358         }
 359     }
 360     private static efl_canvas_group_need_recalculate_get_delegate efl_canvas_group_need_recalculate_get_static_delegate;
 361
 362
 363      private delegate void efl_canvas_group_need_recalculate_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool value);
 364
 365
 366      public delegate void efl_canvas_group_need_recalculate_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool value);
 367      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");
 368      private static void group_need_recalculate_set(System.IntPtr obj, System.IntPtr pd,  bool value)
 369     {
 370         Eina.Log.Debug("function efl_canvas_group_need_recalculate_set was called");
 371         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 372         if(wrapper != null) {
 373
 374             try {
 375                 ((Group)wrapper).SetGroupNeedRecalculate( value);
 376             } catch (Exception e) {
 377                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 378                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 379             }
 380                                 } else {
 381             efl_canvas_group_need_recalculate_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  value);
 382         }
 383     }
 384     private static efl_canvas_group_need_recalculate_set_delegate efl_canvas_group_need_recalculate_set_static_delegate;
 385
 386
 387     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Canvas.Object efl_canvas_group_clipper_get_delegate(System.IntPtr obj, System.IntPtr pd);
 388
 389
 390     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Canvas.Object efl_canvas_group_clipper_get_api_delegate(System.IntPtr obj);
 391      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");
 392      private static Efl.Canvas.Object group_clipper_get(System.IntPtr obj, System.IntPtr pd)
 393     {
 394         Eina.Log.Debug("function efl_canvas_group_clipper_get was called");
 395         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 396         if(wrapper != null) {
 397                         Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
 398             try {
 399                 _ret_var = ((Group)wrapper).GetGroupClipper();
 400             } catch (Exception e) {
 401                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 402                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 403             }
 404         return _ret_var;
 405         } else {
 406             return efl_canvas_group_clipper_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 407         }
 408     }
 409     private static efl_canvas_group_clipper_get_delegate efl_canvas_group_clipper_get_static_delegate;
 410
 411
 412      private delegate void efl_canvas_group_change_delegate(System.IntPtr obj, System.IntPtr pd);
 413
 414
 415      public delegate void efl_canvas_group_change_api_delegate(System.IntPtr obj);
 416      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");
 417      private static void group_change(System.IntPtr obj, System.IntPtr pd)
 418     {
 419         Eina.Log.Debug("function efl_canvas_group_change was called");
 420         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 421         if(wrapper != null) {
 422
 423             try {
 424                 ((Group)wrapper).GroupChange();
 425             } catch (Exception e) {
 426                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 427                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 428             }
 429                 } else {
 430             efl_canvas_group_change_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 431         }
 432     }
 433     private static efl_canvas_group_change_delegate efl_canvas_group_change_static_delegate;
 434
 435
 436      private delegate void efl_canvas_group_calculate_delegate(System.IntPtr obj, System.IntPtr pd);
 437
 438
 439      public delegate void efl_canvas_group_calculate_api_delegate(System.IntPtr obj);
 440      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");
 441      private static void group_calculate(System.IntPtr obj, System.IntPtr pd)
 442     {
 443         Eina.Log.Debug("function efl_canvas_group_calculate was called");
 444         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 445         if(wrapper != null) {
 446
 447             try {
 448                 ((Group)wrapper).CalculateGroup();
 449             } catch (Exception e) {
 450                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 451                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 452             }
 453                 } else {
 454             efl_canvas_group_calculate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 455         }
 456     }
 457     private static efl_canvas_group_calculate_delegate efl_canvas_group_calculate_static_delegate;
 458
 459
 460      private delegate System.IntPtr efl_canvas_group_members_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 461
 462
 463      public delegate System.IntPtr efl_canvas_group_members_iterate_api_delegate(System.IntPtr obj);
 464      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");
 465      private static System.IntPtr group_members_iterate(System.IntPtr obj, System.IntPtr pd)
 466     {
 467         Eina.Log.Debug("function efl_canvas_group_members_iterate was called");
 468         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 469         if(wrapper != null) {
 470                         Eina.Iterator<Efl.Canvas.Object> _ret_var = default(Eina.Iterator<Efl.Canvas.Object>);
 471             try {
 472                 _ret_var = ((Group)wrapper).GroupMembersIterate();
 473             } catch (Exception e) {
 474                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 475                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 476             }
 477         _ret_var.Own = false; return _ret_var.Handle;
 478         } else {
 479             return efl_canvas_group_members_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 480         }
 481     }
 482     private static efl_canvas_group_members_iterate_delegate efl_canvas_group_members_iterate_static_delegate;
 483
 484
 485      private delegate void efl_canvas_group_member_add_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 486
 487
 488      public delegate void efl_canvas_group_member_add_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 489      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");
 490      private static void group_member_add(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sub_obj)
 491     {
 492         Eina.Log.Debug("function efl_canvas_group_member_add was called");
 493         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 494         if(wrapper != null) {
 495
 496             try {
 497                 ((Group)wrapper).AddGroupMember( sub_obj);
 498             } catch (Exception e) {
 499                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 500                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 501             }
 502                                 } else {
 503             efl_canvas_group_member_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sub_obj);
 504         }
 505     }
 506     private static efl_canvas_group_member_add_delegate efl_canvas_group_member_add_static_delegate;
 507
 508
 509      private delegate void efl_canvas_group_member_remove_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 510
 511
 512      public delegate void efl_canvas_group_member_remove_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 513      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");
 514      private static void group_member_remove(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sub_obj)
 515     {
 516         Eina.Log.Debug("function efl_canvas_group_member_remove was called");
 517         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 518         if(wrapper != null) {
 519
 520             try {
 521                 ((Group)wrapper).GroupMemberRemove( sub_obj);
 522             } catch (Exception e) {
 523                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 524                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 525             }
 526                                 } else {
 527             efl_canvas_group_member_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sub_obj);
 528         }
 529     }
 530     private static efl_canvas_group_member_remove_delegate efl_canvas_group_member_remove_static_delegate;
 531
 532
 533      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_group_member_is_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 534
 535
 536      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_group_member_is_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
 537      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");
 538      private static bool group_member_is(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sub_obj)
 539     {
 540         Eina.Log.Debug("function efl_canvas_group_member_is was called");
 541         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 542         if(wrapper != null) {
 543                                                 bool _ret_var = default(bool);
 544             try {
 545                 _ret_var = ((Group)wrapper).IsGroupMember( sub_obj);
 546             } catch (Exception e) {
 547                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 548                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 549             }
 550                         return _ret_var;
 551         } else {
 552             return efl_canvas_group_member_is_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sub_obj);
 553         }
 554     }
 555     private static efl_canvas_group_member_is_delegate efl_canvas_group_member_is_static_delegate;
 556 }
 557 } }