internals/src/EflSharp/EflSharp/efl_canvas_layout.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.Layout.PartInvalidEvt"/>.</summary>
   9 public class LayoutPartInvalidEvt_Args : EventArgs {
  10    ///<summary>Actual event payload.</summary>
  11    public  System.String arg { get; set; }
  12 }
  13 /// <summary>Edje object class</summary>
  14 [LayoutNativeInherit]
  15 public class Layout : Efl.Canvas.Group, Efl.Eo.IWrapper,Efl.Container,Efl.File,Efl.Observer,Efl.Part,Efl.Player,Efl.Gfx.ColorClass,Efl.Gfx.SizeClass,Efl.Gfx.TextClass,Efl.Layout.Calc,Efl.Layout.Group,Efl.Layout.Signal
  16 {
  17    public new static System.IntPtr klass = System.IntPtr.Zero;
  18    public new static Efl.Canvas.LayoutNativeInherit nativeInherit = new Efl.Canvas.LayoutNativeInherit();
  19    ///<summary>Pointer to the native class description.</summary>
  20    public override System.IntPtr NativeClass {
  21       get {
  22          if (((object)this).GetType() == typeof (Layout))
  23             return Efl.Canvas.LayoutNativeInherit.GetEflClassStatic();
  24          else
  25             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  26       }
  27    }
  28    [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  29       efl_canvas_layout_class_get();
  30    ///<summary>Creates a new instance.</summary>
  31    ///<param name="parent">Parent instance.</param>
  32    public Layout(Efl.Object parent= null
  33          ) :
  34       base(efl_canvas_layout_class_get(), typeof(Layout), parent)
  35    {
  36       FinishInstantiation();
  37    }
  38    ///<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>
  39    public Layout(System.IntPtr raw) : base(raw)
  40    {
  41             register_event_proxies();
  42    }
  43    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  44    protected Layout(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  45    ///<summary>Casts obj into an instance of this type.</summary>
  46    public new static Layout static_cast(Efl.Object obj)
  47    {
  48       if (obj == null)
  49          throw new System.ArgumentNullException("obj");
  50       return new Layout(obj.NativeHandle);
  51    }
  52    ///<summary>Verifies if the given object is equal to this one.</summary>
  53    public override bool Equals(object obj)
  54    {
  55       var other = obj as Efl.Object;
  56       if (other == null)
  57          return false;
  58       return this.NativeHandle == other.NativeHandle;
  59    }
  60    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  61    public override int GetHashCode()
  62    {
  63       return this.NativeHandle.ToInt32();
  64    }
  65    ///<summary>Turns the native pointer into a string representation.</summary>
  66    public override String ToString()
  67    {
  68       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  69    }
  70 private static object PartInvalidEvtKey = new object();
  71    /// <summary>Emitted when trying to use an invalid part. The value passed is the part name.</summary>
  72    public event EventHandler<Efl.Canvas.LayoutPartInvalidEvt_Args> PartInvalidEvt
  73    {
  74       add {
  75          lock (eventLock) {
  76             string key = "_EFL_LAYOUT_EVENT_PART_INVALID";
  77             if (add_cpp_event_handler(efl.Libs.Edje, key, this.evt_PartInvalidEvt_delegate)) {
  78                eventHandlers.AddHandler(PartInvalidEvtKey , value);
  79             } else
  80                Eina.Log.Error($"Error adding proxy for event {key}");
  81          }
  82       }
  83       remove {
  84          lock (eventLock) {
  85             string key = "_EFL_LAYOUT_EVENT_PART_INVALID";
  86             if (remove_cpp_event_handler(key, this.evt_PartInvalidEvt_delegate)) {
  87                eventHandlers.RemoveHandler(PartInvalidEvtKey , value);
  88             } else
  89                Eina.Log.Error($"Error removing proxy for event {key}");
  90          }
  91       }
  92    }
  93    ///<summary>Method to raise event PartInvalidEvt.</summary>
  94    public void On_PartInvalidEvt(Efl.Canvas.LayoutPartInvalidEvt_Args e)
  95    {
  96       EventHandler<Efl.Canvas.LayoutPartInvalidEvt_Args> evt;
  97       lock (eventLock) {
  98       evt = (EventHandler<Efl.Canvas.LayoutPartInvalidEvt_Args>)eventHandlers[PartInvalidEvtKey];
  99       }
 100       evt?.Invoke(this, e);
 101    }
 102    Efl.EventCb evt_PartInvalidEvt_delegate;
 103    private void on_PartInvalidEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 104    {
 105       Efl.Canvas.LayoutPartInvalidEvt_Args args = new Efl.Canvas.LayoutPartInvalidEvt_Args();
 106       args.arg = Eina.StringConversion.NativeUtf8ToManagedString(evt.Info);
 107       try {
 108          On_PartInvalidEvt(args);
 109       } catch (Exception e) {
 110          Eina.Log.Error(e.ToString());
 111          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 112       }
 113    }
 114
 115 private static object ContentAddedEvtKey = new object();
 116    /// <summary>Sent after a new item was added.</summary>
 117    public event EventHandler<Efl.ContainerContentAddedEvt_Args> ContentAddedEvt
 118    {
 119       add {
 120          lock (eventLock) {
 121             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 122             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentAddedEvt_delegate)) {
 123                eventHandlers.AddHandler(ContentAddedEvtKey , value);
 124             } else
 125                Eina.Log.Error($"Error adding proxy for event {key}");
 126          }
 127       }
 128       remove {
 129          lock (eventLock) {
 130             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 131             if (remove_cpp_event_handler(key, this.evt_ContentAddedEvt_delegate)) {
 132                eventHandlers.RemoveHandler(ContentAddedEvtKey , value);
 133             } else
 134                Eina.Log.Error($"Error removing proxy for event {key}");
 135          }
 136       }
 137    }
 138    ///<summary>Method to raise event ContentAddedEvt.</summary>
 139    public void On_ContentAddedEvt(Efl.ContainerContentAddedEvt_Args e)
 140    {
 141       EventHandler<Efl.ContainerContentAddedEvt_Args> evt;
 142       lock (eventLock) {
 143       evt = (EventHandler<Efl.ContainerContentAddedEvt_Args>)eventHandlers[ContentAddedEvtKey];
 144       }
 145       evt?.Invoke(this, e);
 146    }
 147    Efl.EventCb evt_ContentAddedEvt_delegate;
 148    private void on_ContentAddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 149    {
 150       Efl.ContainerContentAddedEvt_Args args = new Efl.ContainerContentAddedEvt_Args();
 151       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 152       try {
 153          On_ContentAddedEvt(args);
 154       } catch (Exception e) {
 155          Eina.Log.Error(e.ToString());
 156          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 157       }
 158    }
 159
 160 private static object ContentRemovedEvtKey = new object();
 161    /// <summary>Sent after an item was removed, before unref.</summary>
 162    public event EventHandler<Efl.ContainerContentRemovedEvt_Args> ContentRemovedEvt
 163    {
 164       add {
 165          lock (eventLock) {
 166             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 167             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentRemovedEvt_delegate)) {
 168                eventHandlers.AddHandler(ContentRemovedEvtKey , value);
 169             } else
 170                Eina.Log.Error($"Error adding proxy for event {key}");
 171          }
 172       }
 173       remove {
 174          lock (eventLock) {
 175             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 176             if (remove_cpp_event_handler(key, this.evt_ContentRemovedEvt_delegate)) {
 177                eventHandlers.RemoveHandler(ContentRemovedEvtKey , value);
 178             } else
 179                Eina.Log.Error($"Error removing proxy for event {key}");
 180          }
 181       }
 182    }
 183    ///<summary>Method to raise event ContentRemovedEvt.</summary>
 184    public void On_ContentRemovedEvt(Efl.ContainerContentRemovedEvt_Args e)
 185    {
 186       EventHandler<Efl.ContainerContentRemovedEvt_Args> evt;
 187       lock (eventLock) {
 188       evt = (EventHandler<Efl.ContainerContentRemovedEvt_Args>)eventHandlers[ContentRemovedEvtKey];
 189       }
 190       evt?.Invoke(this, e);
 191    }
 192    Efl.EventCb evt_ContentRemovedEvt_delegate;
 193    private void on_ContentRemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 194    {
 195       Efl.ContainerContentRemovedEvt_Args args = new Efl.ContainerContentRemovedEvt_Args();
 196       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 197       try {
 198          On_ContentRemovedEvt(args);
 199       } catch (Exception e) {
 200          Eina.Log.Error(e.ToString());
 201          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 202       }
 203    }
 204
 205 private static object RecalcEvtKey = new object();
 206    /// <summary>The layout was recalculated.
 207    /// 1.21</summary>
 208    public event EventHandler RecalcEvt
 209    {
 210       add {
 211          lock (eventLock) {
 212             string key = "_EFL_LAYOUT_EVENT_RECALC";
 213             if (add_cpp_event_handler(efl.Libs.Edje, key, this.evt_RecalcEvt_delegate)) {
 214                eventHandlers.AddHandler(RecalcEvtKey , value);
 215             } else
 216                Eina.Log.Error($"Error adding proxy for event {key}");
 217          }
 218       }
 219       remove {
 220          lock (eventLock) {
 221             string key = "_EFL_LAYOUT_EVENT_RECALC";
 222             if (remove_cpp_event_handler(key, this.evt_RecalcEvt_delegate)) {
 223                eventHandlers.RemoveHandler(RecalcEvtKey , value);
 224             } else
 225                Eina.Log.Error($"Error removing proxy for event {key}");
 226          }
 227       }
 228    }
 229    ///<summary>Method to raise event RecalcEvt.</summary>
 230    public void On_RecalcEvt(EventArgs e)
 231    {
 232       EventHandler evt;
 233       lock (eventLock) {
 234       evt = (EventHandler)eventHandlers[RecalcEvtKey];
 235       }
 236       evt?.Invoke(this, e);
 237    }
 238    Efl.EventCb evt_RecalcEvt_delegate;
 239    private void on_RecalcEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 240    {
 241       EventArgs args = EventArgs.Empty;
 242       try {
 243          On_RecalcEvt(args);
 244       } catch (Exception e) {
 245          Eina.Log.Error(e.ToString());
 246          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 247       }
 248    }
 249
 250 private static object CircularDependencyEvtKey = new object();
 251    /// <summary>A circular dependency between parts of the object was found.
 252    /// 1.21</summary>
 253    public event EventHandler CircularDependencyEvt
 254    {
 255       add {
 256          lock (eventLock) {
 257             string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
 258             if (add_cpp_event_handler(efl.Libs.Edje, key, this.evt_CircularDependencyEvt_delegate)) {
 259                eventHandlers.AddHandler(CircularDependencyEvtKey , value);
 260             } else
 261                Eina.Log.Error($"Error adding proxy for event {key}");
 262          }
 263       }
 264       remove {
 265          lock (eventLock) {
 266             string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
 267             if (remove_cpp_event_handler(key, this.evt_CircularDependencyEvt_delegate)) {
 268                eventHandlers.RemoveHandler(CircularDependencyEvtKey , value);
 269             } else
 270                Eina.Log.Error($"Error removing proxy for event {key}");
 271          }
 272       }
 273    }
 274    ///<summary>Method to raise event CircularDependencyEvt.</summary>
 275    public void On_CircularDependencyEvt(EventArgs e)
 276    {
 277       EventHandler evt;
 278       lock (eventLock) {
 279       evt = (EventHandler)eventHandlers[CircularDependencyEvtKey];
 280       }
 281       evt?.Invoke(this, e);
 282    }
 283    Efl.EventCb evt_CircularDependencyEvt_delegate;
 284    private void on_CircularDependencyEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 285    {
 286       EventArgs args = EventArgs.Empty;
 287       try {
 288          On_CircularDependencyEvt(args);
 289       } catch (Exception e) {
 290          Eina.Log.Error(e.ToString());
 291          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 292       }
 293    }
 294
 295    protected override void register_event_proxies()
 296    {
 297       base.register_event_proxies();
 298       evt_PartInvalidEvt_delegate = new Efl.EventCb(on_PartInvalidEvt_NativeCallback);
 299       evt_ContentAddedEvt_delegate = new Efl.EventCb(on_ContentAddedEvt_NativeCallback);
 300       evt_ContentRemovedEvt_delegate = new Efl.EventCb(on_ContentRemovedEvt_NativeCallback);
 301       evt_RecalcEvt_delegate = new Efl.EventCb(on_RecalcEvt_NativeCallback);
 302       evt_CircularDependencyEvt_delegate = new Efl.EventCb(on_CircularDependencyEvt_NativeCallback);
 303    }
 304    /// <summary>Get the current state of animation, <c>true</c> by default.</summary>
 305    /// <returns>The animation state, <c>true</c> by default.</returns>
 306    virtual public bool GetAnimation() {
 307        var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_animation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 308       Eina.Error.RaiseIfUnhandledException();
 309       return _ret_var;
 310  }
 311    /// <summary>Start or stop animating this object.</summary>
 312    /// <param name="on">The animation state, <c>true</c> by default.</param>
 313    /// <returns></returns>
 314    virtual public  void SetAnimation( bool on) {
 315                          Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_animation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), on);
 316       Eina.Error.RaiseIfUnhandledException();
 317                    }
 318    /// <summary>Returns the seat device given its Edje&apos;s name.
 319    /// Edje references seats by a name that differs from Evas. Edje naming follows a incrementional convention: first registered name is &quot;seat1&quot;, second is &quot;seat2&quot;, differently from Evas.
 320    /// 1.19</summary>
 321    /// <param name="name">The name&apos;s character string.</param>
 322    /// <returns>The seat device or <c>null</c> if not found.</returns>
 323    virtual public Efl.Input.Device GetSeat(  System.String name) {
 324                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_seat_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name);
 325       Eina.Error.RaiseIfUnhandledException();
 326                   return _ret_var;
 327  }
 328    /// <summary>Gets the name given to a set by Edje.
 329    /// Edje references seats by a name that differs from Evas. Edje naming follows a incrementional convention: first registered name is &quot;seat1&quot;, second is &quot;seat2&quot;, differently from Evas.
 330    /// 1.19</summary>
 331    /// <param name="device">The seat device</param>
 332    /// <returns>The name&apos;s character string or <c>null</c> if not found.</returns>
 333    virtual public  System.String GetSeatName( Efl.Input.Device device) {
 334                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_seat_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), device);
 335       Eina.Error.RaiseIfUnhandledException();
 336                   return _ret_var;
 337  }
 338    /// <summary>Gets the (last) file loading error for a given object.</summary>
 339    /// <returns>The load error code.</returns>
 340    virtual public Efl.Gfx.ImageLoadError GetLayoutLoadError() {
 341        var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_load_error_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 342       Eina.Error.RaiseIfUnhandledException();
 343       return _ret_var;
 344  }
 345    /// <summary>Gets the object text min calculation policy.
 346    /// Do not use this API without understanding whats going on. It is made for internal usage.
 347    ///
 348    /// @if MOBILE @since_tizen 3.0 @elseif WEARABLE @since_tizen 3.0 @endif @internal</summary>
 349    /// <param name="part">The part name</param>
 350    /// <param name="state_name">The state name</param>
 351    /// <param name="min_x">The min width policy</param>
 352    /// <param name="min_y">The min height policy</param>
 353    /// <returns><c>true</c> on success, or <c>false</c> on error</returns>
 354    virtual public bool GetPartTextMinPolicy(  System.String part,   System.String state_name,  out bool min_x,  out bool min_y) {
 355                                                                                var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_min_policy_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  state_name,  out min_x,  out min_y);
 356       Eina.Error.RaiseIfUnhandledException();
 357                                                       return _ret_var;
 358  }
 359    /// <summary>Sets the object text min calculation policy.
 360    /// Do not use this API without understanding whats going on. It is made for internal usage.
 361    ///
 362    /// @if MOBILE @since_tizen 3.0 @elseif WEARABLE @since_tizen 3.0 @endif @internal</summary>
 363    /// <param name="part">The part name</param>
 364    /// <param name="state_name">The state name</param>
 365    /// <param name="min_x">The min width policy</param>
 366    /// <param name="min_y">The min height policy</param>
 367    /// <returns><c>true</c> on success, or <c>false</c> on error</returns>
 368    virtual public bool SetPartTextMinPolicy(  System.String part,   System.String state_name,  bool min_x,  bool min_y) {
 369                                                                                var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_min_policy_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  state_name,  min_x,  min_y);
 370       Eina.Error.RaiseIfUnhandledException();
 371                                                       return _ret_var;
 372  }
 373    /// <summary>Gets the valign for text.
 374    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 375    /// <param name="part">The part name</param>
 376    /// <returns>The valign 0.0~1.0. -1.0 for respect EDC&apos;s align value.</returns>
 377    virtual public double GetPartTextValign(  System.String part) {
 378                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_valign_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
 379       Eina.Error.RaiseIfUnhandledException();
 380                   return _ret_var;
 381  }
 382    /// <summary>Sets the valign for text.
 383    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 384    /// <param name="part">The part name</param>
 385    /// <param name="valign">The valign 0.0~1.0. -1.0 for respect EDC&apos;s align value.</param>
 386    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 387    virtual public bool SetPartTextValign(  System.String part,  double valign) {
 388                                            var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_valign_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  valign);
 389       Eina.Error.RaiseIfUnhandledException();
 390                               return _ret_var;
 391  }
 392    /// <summary>Gets the duration for text&apos;s marquee.
 393    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 394    /// <param name="part">The part name</param>
 395    /// <returns>The duration. 0.0 for respect EDC&apos;s duration value.</returns>
 396    virtual public double GetPartTextMarqueeDuration(  System.String part) {
 397                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_duration_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
 398       Eina.Error.RaiseIfUnhandledException();
 399                   return _ret_var;
 400  }
 401    /// <summary>Sets the duration for text&apos;s marquee.
 402    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 403    /// <param name="part">The part name</param>
 404    /// <param name="duration">The duration. 0.0 for respect EDC&apos;s duration value.</param>
 405    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 406    virtual public bool SetPartTextMarqueeDuration(  System.String part,  double duration) {
 407                                            var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_duration_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  duration);
 408       Eina.Error.RaiseIfUnhandledException();
 409                               return _ret_var;
 410  }
 411    /// <summary>Gets the speed for text&apos;s marquee.
 412    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 413    /// <param name="part">The part name</param>
 414    /// <returns>The speed. 0.0 for respect EDC&apos;s speed value.</returns>
 415    virtual public double GetPartTextMarqueeSpeed(  System.String part) {
 416                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_speed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
 417       Eina.Error.RaiseIfUnhandledException();
 418                   return _ret_var;
 419  }
 420    /// <summary>Sets the speed for text&apos;s marquee.
 421    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 422    /// <param name="part">The part name</param>
 423    /// <param name="speed">The speed. 0.0 for respect EDC&apos;s speed value.</param>
 424    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 425    virtual public bool SetPartTextMarqueeSpeed(  System.String part,  double speed) {
 426                                            var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_speed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  speed);
 427       Eina.Error.RaiseIfUnhandledException();
 428                               return _ret_var;
 429  }
 430    /// <summary>Gets the always mode for text&apos;s marquee.
 431    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 432    /// <param name="part">The part name</param>
 433    /// <returns>The always mode</returns>
 434    virtual public bool GetPartTextMarqueeAlways(  System.String part) {
 435                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_always_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
 436       Eina.Error.RaiseIfUnhandledException();
 437                   return _ret_var;
 438  }
 439    /// <summary>Sets the always mode for text&apos;s marquee.
 440    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 441    /// <param name="part">The part name</param>
 442    /// <param name="always">The always mode</param>
 443    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 444    virtual public bool SetPartTextMarqueeAlways(  System.String part,  bool always) {
 445                                            var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_marquee_always_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  always);
 446       Eina.Error.RaiseIfUnhandledException();
 447                               return _ret_var;
 448  }
 449    /// <summary>Gets the valign for a common description.
 450    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 451    /// <param name="part">The part name</param>
 452    /// <returns>The valign 0.0~1.0. -1.0 for respect EDC&apos;s align value.</returns>
 453    virtual public double GetPartValign(  System.String part) {
 454                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_valign_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
 455       Eina.Error.RaiseIfUnhandledException();
 456                   return _ret_var;
 457  }
 458    /// <summary>Sets the valign for a common description.
 459    /// Do not use this API without understanding whats going on. It is made for internal usage. @internal</summary>
 460    /// <param name="part">The part name</param>
 461    /// <param name="valign">The valign 0.0~1.0. -1.0 for respect EDC&apos;s align value.</param>
 462    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 463    virtual public bool SetPartValign(  System.String part,  double valign) {
 464                                            var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_valign_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  valign);
 465       Eina.Error.RaiseIfUnhandledException();
 466                               return _ret_var;
 467  }
 468    /// <summary>Iterates over all accessibility-enabled part names.</summary>
 469    /// <returns>Part name iterator</returns>
 470    virtual public Eina.Iterator< System.String> AccessPartIterate() {
 471        var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_access_part_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 472       Eina.Error.RaiseIfUnhandledException();
 473       return new Eina.Iterator< System.String>(_ret_var, true, false);
 474  }
 475    /// <summary>Unswallow an object from this Edje.</summary>
 476    /// <param name="content">To be removed content.</param>
 477    /// <returns><c>false</c> if <c>content</c> was not a child or can not be removed.</returns>
 478    virtual public bool ContentRemove( Efl.Gfx.Entity content) {
 479                          var _ret_var = Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_content_remove_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), content);
 480       Eina.Error.RaiseIfUnhandledException();
 481                   return _ret_var;
 482  }
 483    /// <summary>Sets the parent object for color class.
 484    /// @if MOBILE @since_tizen 3.0 @elseif WEARABLE @since_tizen 3.0 @endif @internal</summary>
 485    /// <param name="parent">The parent object for color class</param>
 486    /// <returns></returns>
 487    virtual public  void SetColorClassParent( Efl.Object parent) {
 488                          Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_color_class_parent_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), parent);
 489       Eina.Error.RaiseIfUnhandledException();
 490                    }
 491    /// <summary>Unsets the parent object for color class.
 492    /// @if MOBILE @since_tizen 3.0 @elseif WEARABLE @since_tizen 3.0 @endif @internal</summary>
 493    /// <returns></returns>
 494    virtual public  void UnsetColorClassParent() {
 495        Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_color_class_parent_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 496       Eina.Error.RaiseIfUnhandledException();
 497        }
 498    /// <summary>Get a position of the given cursor
 499    /// @internal</summary>
 500    /// <param name="part">The part name</param>
 501    /// <param name="cur">cursor type</param>
 502    /// <param name="x">w</param>
 503    /// <param name="y">h</param>
 504    /// <returns></returns>
 505    virtual public  void GetPartTextCursorCoord(  System.String part,  Edje.Cursor cur,  out  int x,  out  int y) {
 506                                                                                Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_cursor_coord_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  cur,  out x,  out y);
 507       Eina.Error.RaiseIfUnhandledException();
 508                                                        }
 509    /// <summary>Get a size of the given cursor
 510    /// @internal</summary>
 511    /// <param name="part">The part name</param>
 512    /// <param name="cur">cursor type</param>
 513    /// <param name="w">w</param>
 514    /// <param name="h">h</param>
 515    /// <returns></returns>
 516    virtual public  void GetPartTextCursorSize(  System.String part,  Edje.Cursor cur,  out  int w,  out  int h) {
 517                                                                                Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_cursor_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  cur,  out w,  out h);
 518       Eina.Error.RaiseIfUnhandledException();
 519                                                        }
 520    /// <summary>Returns the cursor geometry of the part relative to the edje object. The cursor geometry is kept in mouse down and move.
 521    /// @internal @if MOBILE @since_tizen 3.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
 522    /// <param name="part">The part name</param>
 523    /// <param name="x">Cursor X position</param>
 524    /// <param name="y">Cursor Y position</param>
 525    /// <param name="w">Cursor width</param>
 526    /// <param name="h">Cursor height</param>
 527    /// <returns></returns>
 528    virtual public  void GetPartTextCursorOnMouseGeometry(  System.String part,  out  int x,  out  int y,  out  int w,  out  int h) {
 529                                                                                                  Efl.Canvas.LayoutNativeInherit.efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part,  out x,  out y,  out w,  out h);
 530       Eina.Error.RaiseIfUnhandledException();
 531                                                                    }
 532    /// <summary>Begin iterating over this object&apos;s contents.</summary>
 533    /// <returns>Iterator to object content</returns>
 534    virtual public Eina.Iterator<Efl.Gfx.Entity> ContentIterate() {
 535        var _ret_var = Efl.ContainerNativeInherit.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 536       Eina.Error.RaiseIfUnhandledException();
 537       return new Eina.Iterator<Efl.Gfx.Entity>(_ret_var, true, false);
 538  }
 539    /// <summary>Returns the number of UI elements packed in this container.</summary>
 540    /// <returns>Number of packed UI elements</returns>
 541    virtual public  int ContentCount() {
 542        var _ret_var = Efl.ContainerNativeInherit.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 543       Eina.Error.RaiseIfUnhandledException();
 544       return _ret_var;
 545  }
 546    /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
 547    /// <returns>The handle to an Eina_File that will be used</returns>
 548    virtual public Eina.File GetMmap() {
 549        var _ret_var = Efl.FileNativeInherit.efl_file_mmap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 550       Eina.Error.RaiseIfUnhandledException();
 551       return _ret_var;
 552  }
 553    /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an Eina_File).
 554    /// If mmap is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
 555    /// <param name="f">The handle to an Eina_File that will be used</param>
 556    /// <returns>0 on success, error code otherwise</returns>
 557    virtual public  Eina.Error SetMmap( Eina.File f) {
 558                          var _ret_var = Efl.FileNativeInherit.efl_file_mmap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), f);
 559       Eina.Error.RaiseIfUnhandledException();
 560                   return _ret_var;
 561  }
 562    /// <summary>Retrieve the file path from where an object is to fetch the data.
 563    /// You must not modify the strings on the returned pointers.</summary>
 564    /// <returns>The file path.</returns>
 565    virtual public  System.String GetFile() {
 566        var _ret_var = Efl.FileNativeInherit.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 567       Eina.Error.RaiseIfUnhandledException();
 568       return _ret_var;
 569  }
 570    /// <summary>Set the file path from where an object will fetch the data.
 571    /// If file is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
 572    /// <param name="file">The file path.</param>
 573    /// <returns>0 on success, error code otherwise</returns>
 574    virtual public  Eina.Error SetFile(  System.String file) {
 575                          var _ret_var = Efl.FileNativeInherit.efl_file_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), file);
 576       Eina.Error.RaiseIfUnhandledException();
 577                   return _ret_var;
 578  }
 579    /// <summary>Get the previously-set key which corresponds to the target data within a file.
 580    /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 581    ///
 582    /// You must not modify the strings on the returned pointers.</summary>
 583    /// <returns>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</returns>
 584    virtual public  System.String GetKey() {
 585        var _ret_var = Efl.FileNativeInherit.efl_file_key_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 586       Eina.Error.RaiseIfUnhandledException();
 587       return _ret_var;
 588  }
 589    /// <summary>Set the key which corresponds to the target data within a file.
 590    /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.</summary>
 591    /// <param name="key">The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</param>
 592    /// <returns></returns>
 593    virtual public  void SetKey(  System.String key) {
 594                          Efl.FileNativeInherit.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key);
 595       Eina.Error.RaiseIfUnhandledException();
 596                    }
 597    /// <summary>Get the load state of the object.</summary>
 598    /// <returns>True if the object is loaded, otherwise false.</returns>
 599    virtual public bool GetLoaded() {
 600        var _ret_var = Efl.FileNativeInherit.efl_file_loaded_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 601       Eina.Error.RaiseIfUnhandledException();
 602       return _ret_var;
 603  }
 604    /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.File.File"/> (or <see cref="Efl.File.Mmap"/>) and <see cref="Efl.File.Key"/> properties.
 605    /// In the case where <see cref="Efl.File.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.File.SetMmap"/> on the object using the opened file handle.
 606    ///
 607    /// Calling <see cref="Efl.File.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.</summary>
 608    /// <returns>0 on success, error code otherwise</returns>
 609    virtual public  Eina.Error Load() {
 610        var _ret_var = Efl.FileNativeInherit.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 611       Eina.Error.RaiseIfUnhandledException();
 612       return _ret_var;
 613  }
 614    /// <summary>Perform all necessary operations to unload file data from the object.
 615    /// In the case where <see cref="Efl.File.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 616    ///
 617    /// Calling <see cref="Efl.File.Unload"/> on an object which is not currently loaded will have no effect.</summary>
 618    /// <returns></returns>
 619    virtual public  void Unload() {
 620        Efl.FileNativeInherit.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 621       Eina.Error.RaiseIfUnhandledException();
 622        }
 623    /// <summary>Update observer according to the changes of observable object.
 624    /// 1.19</summary>
 625    /// <param name="obs">An observable object</param>
 626    /// <param name="key">A key to classify observer groups</param>
 627    /// <param name="data">Required data to update the observer, usually passed by observable object</param>
 628    /// <returns></returns>
 629    virtual public  void Update( Efl.Object obs,   System.String key,   System.IntPtr data) {
 630                                                              Efl.ObserverNativeInherit.efl_observer_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), obs,  key,  data);
 631       Eina.Error.RaiseIfUnhandledException();
 632                                            }
 633    /// <summary>Get a proxy object referring to a part of an object.</summary>
 634    /// <param name="name">The part name.</param>
 635    /// <returns>A (proxy) object, valid for a single call.</returns>
 636    virtual public Efl.Object GetPart(  System.String name) {
 637                          var _ret_var = Efl.PartNativeInherit.efl_part_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name);
 638       Eina.Error.RaiseIfUnhandledException();
 639                   return _ret_var;
 640  }
 641    /// <summary>Whether or not the playable can be played.</summary>
 642    /// <returns><c>true</c> if the object have playable data, <c>false</c> otherwise</returns>
 643    virtual public bool GetPlayable() {
 644        var _ret_var = Efl.PlayerNativeInherit.efl_player_playable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 645       Eina.Error.RaiseIfUnhandledException();
 646       return _ret_var;
 647  }
 648    /// <summary>Get play/pause state of the media file.</summary>
 649    /// <returns><c>true</c> if playing, <c>false</c> otherwise.</returns>
 650    virtual public bool GetPlay() {
 651        var _ret_var = Efl.PlayerNativeInherit.efl_player_play_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 652       Eina.Error.RaiseIfUnhandledException();
 653       return _ret_var;
 654  }
 655    /// <summary>Set play/pause state of the media file.
 656    /// This functions sets the currently playing status of the video. Using this function to play or pause the video doesn&apos;t alter it&apos;s current position.</summary>
 657    /// <param name="play"><c>true</c> if playing, <c>false</c> otherwise.</param>
 658    /// <returns></returns>
 659    virtual public  void SetPlay( bool play) {
 660                          Efl.PlayerNativeInherit.efl_player_play_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), play);
 661       Eina.Error.RaiseIfUnhandledException();
 662                    }
 663    /// <summary>Get the position in the media file.
 664    /// The position is returned as the number of seconds since the beginning of the media file.</summary>
 665    /// <returns>The position (in seconds).</returns>
 666    virtual public double GetPos() {
 667        var _ret_var = Efl.PlayerNativeInherit.efl_player_pos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 668       Eina.Error.RaiseIfUnhandledException();
 669       return _ret_var;
 670  }
 671    /// <summary>Set the position in the media file.
 672    /// This functions sets the current position of the media file to &quot;sec&quot;, this only works on seekable streams. Setting the position doesn&apos;t change the playing state of the media file.</summary>
 673    /// <param name="sec">The position (in seconds).</param>
 674    /// <returns></returns>
 675    virtual public  void SetPos( double sec) {
 676                          Efl.PlayerNativeInherit.efl_player_pos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sec);
 677       Eina.Error.RaiseIfUnhandledException();
 678                    }
 679    /// <summary>Get how much of the file has been played.
 680    /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
 681    /// <returns>The progress within the [0, 1] range.</returns>
 682    virtual public double GetProgress() {
 683        var _ret_var = Efl.PlayerNativeInherit.efl_player_progress_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 684       Eina.Error.RaiseIfUnhandledException();
 685       return _ret_var;
 686  }
 687    /// <summary>Control the play speed of the media file.
 688    /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
 689    /// <returns>The play speed in the [0, infinity) range.</returns>
 690    virtual public double GetPlaySpeed() {
 691        var _ret_var = Efl.PlayerNativeInherit.efl_player_play_speed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 692       Eina.Error.RaiseIfUnhandledException();
 693       return _ret_var;
 694  }
 695    /// <summary>Control the play speed of the media file.
 696    /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
 697    /// <param name="speed">The play speed in the [0, infinity) range.</param>
 698    /// <returns></returns>
 699    virtual public  void SetPlaySpeed( double speed) {
 700                          Efl.PlayerNativeInherit.efl_player_play_speed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), speed);
 701       Eina.Error.RaiseIfUnhandledException();
 702                    }
 703    /// <summary>Control the audio volume.
 704    /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 705    /// <returns>The volume level</returns>
 706    virtual public double GetVolume() {
 707        var _ret_var = Efl.PlayerNativeInherit.efl_player_volume_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 708       Eina.Error.RaiseIfUnhandledException();
 709       return _ret_var;
 710  }
 711    /// <summary>Control the audio volume.
 712    /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 713    /// <param name="volume">The volume level</param>
 714    /// <returns></returns>
 715    virtual public  void SetVolume( double volume) {
 716                          Efl.PlayerNativeInherit.efl_player_volume_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), volume);
 717       Eina.Error.RaiseIfUnhandledException();
 718                    }
 719    /// <summary>This property controls the audio mute state.</summary>
 720    /// <returns>The mute state. <c>true</c> or <c>false</c>.</returns>
 721    virtual public bool GetMute() {
 722        var _ret_var = Efl.PlayerNativeInherit.efl_player_mute_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 723       Eina.Error.RaiseIfUnhandledException();
 724       return _ret_var;
 725  }
 726    /// <summary>This property controls the audio mute state.</summary>
 727    /// <param name="mute">The mute state. <c>true</c> or <c>false</c>.</param>
 728    /// <returns></returns>
 729    virtual public  void SetMute( bool mute) {
 730                          Efl.PlayerNativeInherit.efl_player_mute_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), mute);
 731       Eina.Error.RaiseIfUnhandledException();
 732                    }
 733    /// <summary>Get the length of play for the media file.</summary>
 734    /// <returns>The length of the stream in seconds.</returns>
 735    virtual public double GetLength() {
 736        var _ret_var = Efl.PlayerNativeInherit.efl_player_length_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 737       Eina.Error.RaiseIfUnhandledException();
 738       return _ret_var;
 739  }
 740    /// <summary>Get whether the media file is seekable.</summary>
 741    /// <returns><c>true</c> if seekable.</returns>
 742    virtual public bool GetSeekable() {
 743        var _ret_var = Efl.PlayerNativeInherit.efl_player_seekable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 744       Eina.Error.RaiseIfUnhandledException();
 745       return _ret_var;
 746  }
 747    /// <summary>Start a playing playable object.</summary>
 748    /// <returns></returns>
 749    virtual public  void Start() {
 750        Efl.PlayerNativeInherit.efl_player_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 751       Eina.Error.RaiseIfUnhandledException();
 752        }
 753    /// <summary>Stop playable object.</summary>
 754    /// <returns></returns>
 755    virtual public  void Stop() {
 756        Efl.PlayerNativeInherit.efl_player_stop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 757       Eina.Error.RaiseIfUnhandledException();
 758        }
 759    /// <summary>Get the color of color class.
 760    /// This function gets the color values for a color class. If no explicit object color is set, then global values will be used.
 761    ///
 762    /// The first color is the object, the second is the text outline, and the third is the text shadow. (Note that the second two only apply to text parts).
 763    ///
 764    /// Note: These color values are expected to be premultiplied by <c>a</c>.</summary>
 765    /// <param name="color_class">The name of color class</param>
 766    /// <param name="layer">The layer to set the color</param>
 767    /// <param name="r">The intensity of the red color</param>
 768    /// <param name="g">The intensity of the green color</param>
 769    /// <param name="b">The intensity of the blue color</param>
 770    /// <param name="a">The alpha value</param>
 771    /// <returns><c>true</c> if getting the color succeeded, <c>false</c> otherwise</returns>
 772    virtual public bool GetColorClass(  System.String color_class,  Efl.Gfx.ColorClassLayer layer,  out  int r,  out  int g,  out  int b,  out  int a) {
 773                                                                                                                    var _ret_var = Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class,  layer,  out r,  out g,  out b,  out a);
 774       Eina.Error.RaiseIfUnhandledException();
 775                                                                               return _ret_var;
 776  }
 777    /// <summary>Set the color of color class.
 778    /// This function sets the color values for a color class. This will cause all edje parts in the specified object that have the specified color class to have their colors multiplied by these values.
 779    ///
 780    /// The first color is the object, the second is the text outline, and the third is the text shadow. (Note that the second two only apply to text parts).
 781    ///
 782    /// Setting color emits a signal &quot;color_class,set&quot; with source being the given color.
 783    ///
 784    /// Note: These color values are expected to be premultiplied by <c>a</c>.</summary>
 785    /// <param name="color_class">The name of color class</param>
 786    /// <param name="layer">The layer to set the color</param>
 787    /// <param name="r">The intensity of the red color</param>
 788    /// <param name="g">The intensity of the green color</param>
 789    /// <param name="b">The intensity of the blue color</param>
 790    /// <param name="a">The alpha value</param>
 791    /// <returns><c>true</c> if setting the color succeeded, <c>false</c> otherwise</returns>
 792    virtual public bool SetColorClass(  System.String color_class,  Efl.Gfx.ColorClassLayer layer,   int r,   int g,   int b,   int a) {
 793                                                                                                                    var _ret_var = Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class,  layer,  r,  g,  b,  a);
 794       Eina.Error.RaiseIfUnhandledException();
 795                                                                               return _ret_var;
 796  }
 797    /// <summary>Get the hex color string of color class.
 798    /// This function gets the color values for a color class. If no explicit object color is set, then global values will be used.
 799    ///
 800    /// The first color is the object, the second is the text outline, and the third is the text shadow. (Note that the second two only apply to text parts).
 801    ///
 802    /// Returns NULL if the color class cannot be fetched.
 803    ///
 804    /// Note: These color values are expected to be premultiplied by <c>a</c>.</summary>
 805    /// <param name="color_class">The name of color class</param>
 806    /// <param name="layer">The layer to set the color</param>
 807    /// <returns>the hex color code.</returns>
 808    virtual public  System.String GetColorClassCode(  System.String color_class,  Efl.Gfx.ColorClassLayer layer) {
 809                                            var _ret_var = Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_code_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class,  layer);
 810       Eina.Error.RaiseIfUnhandledException();
 811                               return _ret_var;
 812  }
 813    /// <summary>Set the hex color string of color class.
 814    /// This function sets the color values for a color class. This will cause all edje parts in the specified object that have the specified color class to have their colors multiplied by these values.
 815    ///
 816    /// The first color is the object, the second is the text outline, and the third is the text shadow. (Note that the second two only apply to text parts).
 817    ///
 818    /// Setting color emits a signal &quot;color_class,set&quot; with source being the given color.
 819    ///
 820    /// Note: These color values are expected to be premultiplied by the alpha.</summary>
 821    /// <param name="color_class">The name of color class</param>
 822    /// <param name="layer">The layer to set the color</param>
 823    /// <param name="colorcode">the hex color code.</param>
 824    /// <returns><c>true</c> if setting the color succeeded, <c>false</c> otherwise</returns>
 825    virtual public bool SetColorClassCode(  System.String color_class,  Efl.Gfx.ColorClassLayer layer,   System.String colorcode) {
 826                                                              var _ret_var = Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_code_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class,  layer,  colorcode);
 827       Eina.Error.RaiseIfUnhandledException();
 828                                           return _ret_var;
 829  }
 830    /// <summary>Get the description of a color class.
 831    /// This function gets the description of a color class in use by an object.</summary>
 832    /// <param name="color_class">The name of color class</param>
 833    /// <returns>The description of the target color class or <c>null</c> if not found</returns>
 834    virtual public  System.String GetColorClassDescription(  System.String color_class) {
 835                          var _ret_var = Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_description_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class);
 836       Eina.Error.RaiseIfUnhandledException();
 837                   return _ret_var;
 838  }
 839    /// <summary>Delete the color class.
 840    /// This function deletes any values for the specified color class.
 841    ///
 842    /// Deleting the color class will revert it to the values defined by <see cref="Efl.Gfx.ColorClass.GetColorClass"/> or the color class defined in the theme file.
 843    ///
 844    /// Deleting the color class will emit the signal &quot;color_class,del&quot; for the given Edje object.</summary>
 845    /// <param name="color_class">The name of color_class</param>
 846    /// <returns></returns>
 847    virtual public  void DelColorClass(  System.String color_class) {
 848                          Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), color_class);
 849       Eina.Error.RaiseIfUnhandledException();
 850                    }
 851    /// <summary>Delete all color classes defined in object level.
 852    /// This function deletes any color classes defined in object level. Clearing color classes will revert the color of all edje parts to the values defined in global level or theme file.
 853    /// 1.17.0</summary>
 854    /// <returns></returns>
 855    virtual public  void ClearColorClass() {
 856        Efl.Gfx.ColorClassNativeInherit.efl_gfx_color_class_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 857       Eina.Error.RaiseIfUnhandledException();
 858        }
 859    /// <summary>Get width and height of size class.
 860    /// This function gets width and height for a size class. These values will only be valid until the size class is changed or the edje object is deleted.
 861    /// 1.17</summary>
 862    /// <param name="size_class">The name of size class</param>
 863    /// <param name="minw">minimum width</param>
 864    /// <param name="minh">minimum height</param>
 865    /// <param name="maxw">maximum width</param>
 866    /// <param name="maxh">maximum height</param>
 867    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 868    virtual public bool GetSizeClass(  System.String size_class,  out  int minw,  out  int minh,  out  int maxw,  out  int maxh) {
 869                                                                                                  var _ret_var = Efl.Gfx.SizeClassNativeInherit.efl_gfx_size_class_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), size_class,  out minw,  out minh,  out maxw,  out maxh);
 870       Eina.Error.RaiseIfUnhandledException();
 871                                                                   return _ret_var;
 872  }
 873    /// <summary>Set width and height of size class.
 874    /// This function sets width and height for a size class. This will make all edje parts in the specified object that have the specified size class update their size with given values.
 875    /// 1.17</summary>
 876    /// <param name="size_class">The name of size class</param>
 877    /// <param name="minw">minimum width</param>
 878    /// <param name="minh">minimum height</param>
 879    /// <param name="maxw">maximum width</param>
 880    /// <param name="maxh">maximum height</param>
 881    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 882    virtual public bool SetSizeClass(  System.String size_class,   int minw,   int minh,   int maxw,   int maxh) {
 883                                                                                                  var _ret_var = Efl.Gfx.SizeClassNativeInherit.efl_gfx_size_class_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), size_class,  minw,  minh,  maxw,  maxh);
 884       Eina.Error.RaiseIfUnhandledException();
 885                                                                   return _ret_var;
 886  }
 887    /// <summary>Delete the size class.
 888    /// This function deletes any values for the specified size class.
 889    ///
 890    /// Deleting the size class will revert it to the values defined by <see cref="Efl.Gfx.SizeClass.GetSizeClass"/> or the size class defined in the theme file.
 891    /// 1.17</summary>
 892    /// <param name="size_class">The size class to be deleted.</param>
 893    /// <returns></returns>
 894    virtual public  void DelSizeClass(  System.String size_class) {
 895                          Efl.Gfx.SizeClassNativeInherit.efl_gfx_size_class_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), size_class);
 896       Eina.Error.RaiseIfUnhandledException();
 897                    }
 898    /// <summary>Get font and font size from edje text class.
 899    /// This function gets the font and the font size from text class. The font string will only be valid until the text class is changed or the edje object is deleted.</summary>
 900    /// <param name="text_class">The text class name</param>
 901    /// <param name="font">Font name</param>
 902    /// <param name="size">Font Size</param>
 903    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 904    virtual public bool GetTextClass(  System.String text_class,  out  System.String font,  out Efl.Font.Size size) {
 905                                                              var _ret_var = Efl.Gfx.TextClassNativeInherit.efl_gfx_text_class_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), text_class,  out font,  out size);
 906       Eina.Error.RaiseIfUnhandledException();
 907                                           return _ret_var;
 908  }
 909    /// <summary>Set Edje text class.
 910    /// This function sets the text class for the Edje.</summary>
 911    /// <param name="text_class">The text class name</param>
 912    /// <param name="font">Font name</param>
 913    /// <param name="size">Font Size</param>
 914    /// <returns><c>true</c>, on success or <c>false</c>, on error</returns>
 915    virtual public bool SetTextClass(  System.String text_class,   System.String font,  Efl.Font.Size size) {
 916                                                              var _ret_var = Efl.Gfx.TextClassNativeInherit.efl_gfx_text_class_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), text_class,  font,  size);
 917       Eina.Error.RaiseIfUnhandledException();
 918                                           return _ret_var;
 919  }
 920    /// <summary>Delete the text class.
 921    /// This function deletes any values for the specified text class.
 922    ///
 923    /// Deleting the text class will revert it to the values defined by <see cref="Efl.Gfx.TextClass.GetTextClass"/> or the text class defined in the theme file.
 924    /// 1.17</summary>
 925    /// <param name="text_class">The text class to be deleted.</param>
 926    /// <returns></returns>
 927    virtual public  void DelTextClass(  System.String text_class) {
 928                          Efl.Gfx.TextClassNativeInherit.efl_gfx_text_class_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), text_class);
 929       Eina.Error.RaiseIfUnhandledException();
 930                    }
 931    /// <summary>Whether this object updates its size hints automatically.
 932    /// 1.21</summary>
 933    /// <returns>Whether or not update the size hints.
 934    /// 1.21</returns>
 935    virtual public bool GetCalcAutoUpdateHints() {
 936        var _ret_var = Efl.Layout.CalcNativeInherit.efl_layout_calc_auto_update_hints_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 937       Eina.Error.RaiseIfUnhandledException();
 938       return _ret_var;
 939  }
 940    /// <summary>Enable or disable auto-update of size hints.
 941    /// 1.21</summary>
 942    /// <param name="update">Whether or not update the size hints.
 943    /// 1.21</param>
 944    /// <returns></returns>
 945    virtual public  void SetCalcAutoUpdateHints( bool update) {
 946                          Efl.Layout.CalcNativeInherit.efl_layout_calc_auto_update_hints_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), update);
 947       Eina.Error.RaiseIfUnhandledException();
 948                    }
 949    /// <summary>Calculates the minimum required size for a given layout object.
 950    /// This call will trigger an internal recalculation of all parts of the object, in order to return its minimum required dimensions for width and height. The user might choose to impose those minimum sizes, making the resulting calculation to get to values greater or equal than <c>restricted</c> in both directions.
 951    ///
 952    /// Note: At the end of this call, the object won&apos;t be automatically resized to the new dimensions, but just return the calculated sizes. The caller is the one up to change its geometry or not.
 953    ///
 954    /// Warning: Be advised that invisible parts in the object will be taken into account in this calculation.
 955    /// 1.21</summary>
 956    /// <param name="restricted">The minimum size constraint as input, the returned size can not be lower than this (in both directions).
 957    /// 1.21</param>
 958    /// <returns>The minimum required size.
 959    /// 1.21</returns>
 960    virtual public Eina.Size2D CalcSizeMin( Eina.Size2D restricted) {
 961        var _in_restricted = Eina.Size2D_StructConversion.ToInternal(restricted);
 962                   var _ret_var = Efl.Layout.CalcNativeInherit.efl_layout_calc_size_min_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_restricted);
 963       Eina.Error.RaiseIfUnhandledException();
 964                   return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 965  }
 966    /// <summary>Calculates the geometry of the region, relative to a given layout object&apos;s area, occupied by all parts in the object.
 967    /// This function gets the geometry of the rectangle equal to the area required to group all parts in obj&apos;s group/collection. The x and y coordinates are relative to the top left corner of the whole obj object&apos;s area. Parts placed out of the group&apos;s boundaries will also be taken in account, so that x and y may be negative.
 968    ///
 969    /// Note: On failure, this function will make all non-<c>null</c> geometry pointers&apos; pointed variables be set to zero.
 970    /// 1.21</summary>
 971    /// <returns>The calculated region.
 972    /// 1.21</returns>
 973    virtual public Eina.Rect CalcPartsExtends() {
 974        var _ret_var = Efl.Layout.CalcNativeInherit.efl_layout_calc_parts_extends_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 975       Eina.Error.RaiseIfUnhandledException();
 976       return Eina.Rect_StructConversion.ToManaged(_ret_var);
 977  }
 978    /// <summary>Freezes the layout object.
 979    /// This function puts all changes on hold. Successive freezes will nest, requiring an equal number of thaws.
 980    ///
 981    /// See also <see cref="Efl.Layout.Calc.ThawCalc"/>.
 982    /// 1.21</summary>
 983    /// <returns>The frozen state or 0 on error
 984    /// 1.21</returns>
 985    virtual public  int FreezeCalc() {
 986        var _ret_var = Efl.Layout.CalcNativeInherit.efl_layout_calc_freeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 987       Eina.Error.RaiseIfUnhandledException();
 988       return _ret_var;
 989  }
 990    /// <summary>Thaws the layout object.
 991    /// This function thaws (in other words &quot;unfreezes&quot;) the given layout object.
 992    ///
 993    /// Note: If sucessive freezes were done, an equal number of thaws will be required.
 994    ///
 995    /// See also <see cref="Efl.Layout.Calc.FreezeCalc"/>.
 996    /// 1.21</summary>
 997    /// <returns>The frozen state or 0 if the object is not frozen or on error.
 998    /// 1.21</returns>
 999    virtual public  int ThawCalc() {
1000        var _ret_var = Efl.Layout.CalcNativeInherit.efl_layout_calc_thaw_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1001       Eina.Error.RaiseIfUnhandledException();
1002       return _ret_var;
1003  }
1004    /// <summary>Forces a Size/Geometry calculation.
1005    /// Forces the object to recalculate its layout regardless of freeze/thaw. This API should be used carefully.
1006    ///
1007    /// See also <see cref="Efl.Layout.Calc.FreezeCalc"/> and <see cref="Efl.Layout.Calc.ThawCalc"/>.
1008    /// 1.21</summary>
1009    /// <returns></returns>
1010    virtual public  void CalcForce() {
1011        Efl.Layout.CalcNativeInherit.efl_layout_calc_force_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1012       Eina.Error.RaiseIfUnhandledException();
1013        }
1014    /// <summary>Gets the minimum size specified -- as an EDC property -- for a given Edje object
1015    /// This function retrieves the obj object&apos;s minimum size values, as declared in its EDC group definition. For instance, for an Edje object of minimum size 100x100 pixels: collections { group { name: &quot;a_group&quot;; min: 100 100; } }
1016    ///
1017    /// Note: If the <c>min</c> EDC property was not declared for this object, this call will return 0x0.
1018    ///
1019    /// Note: On failure, this function also return 0x0.
1020    ///
1021    /// See also <see cref="Efl.Layout.Group.GetGroupSizeMax"/>.
1022    /// 1.21</summary>
1023    /// <returns>The minimum size as set in EDC.
1024    /// 1.21</returns>
1025    virtual public Eina.Size2D GetGroupSizeMin() {
1026        var _ret_var = Efl.Layout.GroupNativeInherit.efl_layout_group_size_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1027       Eina.Error.RaiseIfUnhandledException();
1028       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
1029  }
1030    /// <summary>Gets the maximum size specified -- as an EDC property -- for a given Edje object
1031    /// This function retrieves the object&apos;s maximum size values, as declared in its EDC group definition. For instance, for an Edje object of maximum size 100x100 pixels: collections { group { name: &quot;a_group&quot;; max: 100 100; } }
1032    ///
1033    /// Note: If the <c>max</c> EDC property was not declared for the object, this call will return the maximum size a given Edje object may have, for each axis.
1034    ///
1035    /// Note: On failure, this function will return 0x0.
1036    ///
1037    /// See also <see cref="Efl.Layout.Group.GetGroupSizeMin"/>.
1038    /// 1.21</summary>
1039    /// <returns>The maximum size as set in EDC.
1040    /// 1.21</returns>
1041    virtual public Eina.Size2D GetGroupSizeMax() {
1042        var _ret_var = Efl.Layout.GroupNativeInherit.efl_layout_group_size_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1043       Eina.Error.RaiseIfUnhandledException();
1044       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
1045  }
1046    /// <summary>Retrives an EDC data field&apos;s value from a given Edje object&apos;s group.
1047    /// This function fetches an EDC data field&apos;s value, which is declared on the objects building EDC file, under its group. EDC data blocks are most commonly used to pass arbitrary parameters from an application&apos;s theme to its code.
1048    ///
1049    /// EDC data fields always hold  strings as values, hence the return type of this function. Check the complete &quot;syntax reference&quot; for EDC files.
1050    ///
1051    /// This is how a data item is defined in EDC: collections { group { name: &quot;a_group&quot;; data { item: &quot;key1&quot; &quot;value1&quot;; item: &quot;key2&quot; &quot;value2&quot;; } } }
1052    ///
1053    /// Warning: Do not confuse this call with edje_file_data_get(), which queries for a global EDC data field on an EDC declaration file.
1054    /// 1.21</summary>
1055    /// <param name="key">The data field&apos;s key string
1056    /// 1.21</param>
1057    /// <returns>The data&apos;s value string.
1058    /// 1.21</returns>
1059    virtual public  System.String GetGroupData(  System.String key) {
1060                          var _ret_var = Efl.Layout.GroupNativeInherit.efl_layout_group_data_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key);
1061       Eina.Error.RaiseIfUnhandledException();
1062                   return _ret_var;
1063  }
1064    /// <summary>Returns <c>true</c> if the part exists in the EDC group.
1065    /// 1.21</summary>
1066    /// <param name="part">The part name to check.
1067    /// 1.21</param>
1068    /// <returns><c>true</c> if the part exists, <c>false</c> otherwise.
1069    /// 1.21</returns>
1070    virtual public bool GetPartExist(  System.String part) {
1071                          var _ret_var = Efl.Layout.GroupNativeInherit.efl_layout_group_part_exist_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
1072       Eina.Error.RaiseIfUnhandledException();
1073                   return _ret_var;
1074  }
1075    /// <summary>Sends an (Edje) message to a given Edje object
1076    /// This function sends an Edje message to obj and to all of its child objects, if it has any (swallowed objects are one kind of child object). Only a few types are supported: - int, - float/double, - string/stringshare, - arrays of int, float, double or strings.
1077    ///
1078    /// Messages can go both ways, from code to theme, or theme to code.
1079    ///
1080    /// The id argument as a form of code and theme defining a common interface on message communication. One should define the same IDs on both code and EDC declaration, to individualize messages (binding them to a given context).
1081    /// 1.21</summary>
1082    /// <param name="id">A identification number for the message to be sent
1083    /// 1.21</param>
1084    /// <param name="msg">The message&apos;s payload
1085    /// 1.21</param>
1086    /// <returns></returns>
1087    virtual public  void MessageSend(  int id,   Eina.Value msg) {
1088                                            Efl.Layout.SignalNativeInherit.efl_layout_signal_message_send_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id,  msg);
1089       Eina.Error.RaiseIfUnhandledException();
1090                                }
1091    /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
1092    /// Edje signals are one of the communication interfaces between code and a given Edje object&apos;s theme. With signals, one can communicate two string values at a time, which are: - &quot;emission&quot; value: the name of the signal, in general - &quot;source&quot; value: a name for the signal&apos;s context, in general
1093    ///
1094    /// Signals can go both ways, from code to theme, or theme to code.
1095    ///
1096    /// Though there are those common uses for the two strings, one is free to use them however they like.
1097    ///
1098    /// Signal callback registration is powerful, in the way that blobs may be used to match multiple signals at once. All the &quot;*?[&quot; set of <c>fnmatch</c>() operators can be used, both for emission and source.
1099    ///
1100    /// Edje has internal signals it will emit, automatically, on various actions taking place on group parts. For example, the mouse cursor being moved, pressed, released, etc., over a given part&apos;s area, all generate individual signals.
1101    ///
1102    /// With something like emission = &quot;mouse,down,*&quot;, source = &quot;button.*&quot; where &quot;button.*&quot; is the pattern for the names of parts implementing buttons on an interface, you&apos;d be registering for notifications on events of mouse buttons being pressed down on either of those parts (those events all have the &quot;mouse,down,&quot; common prefix on their names, with a suffix giving the button number). The actual emission and source strings of an event will be passed in as the emission and source parameters of the callback function (e.g. &quot;mouse,down,2&quot; and &quot;button.close&quot;), for each of those events.
1103    ///
1104    /// See also the Edje Data Collection Reference for EDC files.
1105    ///
1106    /// See <see cref="Efl.Layout.Signal.EmitSignal"/> on how to emit signals from code to a an object See <see cref="Efl.Layout.Signal.DelSignalCallback"/>.
1107    /// 1.21</summary>
1108    /// <param name="emission">The signal&apos;s &quot;emission&quot; string
1109    /// 1.21</param>
1110    /// <param name="source">The signal&apos;s &quot;source&quot; string
1111    /// 1.21</param>
1112    /// <param name="func">The callback function to be executed when the signal is emitted.
1113    /// 1.21</param>
1114    /// <returns><c>true</c> in case of success, <c>false</c> in case of error.
1115    /// 1.21</returns>
1116    virtual public bool AddSignalCallback(  System.String emission,   System.String source,  EflLayoutSignalCb func) {
1117                                                        GCHandle func_handle = GCHandle.Alloc(func);
1118       var _ret_var = Efl.Layout.SignalNativeInherit.efl_layout_signal_callback_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), emission,  source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
1119       Eina.Error.RaiseIfUnhandledException();
1120                                           return _ret_var;
1121  }
1122    /// <summary>Removes a signal-triggered callback from an object.
1123    /// This function removes a callback, previously attached to the emission of a signal, from the object  obj. The parameters emission, source and func must match exactly those passed to a previous call to <see cref="Efl.Layout.Signal.AddSignalCallback"/>.
1124    ///
1125    /// See <see cref="Efl.Layout.Signal.AddSignalCallback"/>.
1126    /// 1.21</summary>
1127    /// <param name="emission">The signal&apos;s &quot;emission&quot; string
1128    /// 1.21</param>
1129    /// <param name="source">The signal&apos;s &quot;source&quot; string
1130    /// 1.21</param>
1131    /// <param name="func">The callback function to be executed when the signal is emitted.
1132    /// 1.21</param>
1133    /// <returns><c>true</c> in case of success, <c>false</c> in case of error.
1134    /// 1.21</returns>
1135    virtual public bool DelSignalCallback(  System.String emission,   System.String source,  EflLayoutSignalCb func) {
1136                                                        GCHandle func_handle = GCHandle.Alloc(func);
1137       var _ret_var = Efl.Layout.SignalNativeInherit.efl_layout_signal_callback_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), emission,  source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
1138       Eina.Error.RaiseIfUnhandledException();
1139                                           return _ret_var;
1140  }
1141    /// <summary>Sends/emits an Edje signal to this layout.
1142    /// This function sends a signal to the object. An Edje program, at the EDC specification level, can respond to a signal by having declared matching &quot;signal&quot; and &quot;source&quot; fields on its block.
1143    ///
1144    /// See also the Edje Data Collection Reference for EDC files.
1145    ///
1146    /// See <see cref="Efl.Layout.Signal.AddSignalCallback"/> for more on Edje signals.
1147    /// 1.21</summary>
1148    /// <param name="emission">The signal&apos;s &quot;emission&quot; string
1149    /// 1.21</param>
1150    /// <param name="source">The signal&apos;s &quot;source&quot; string
1151    /// 1.21</param>
1152    /// <returns></returns>
1153    virtual public  void EmitSignal(  System.String emission,   System.String source) {
1154                                            Efl.Layout.SignalNativeInherit.efl_layout_signal_emit_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), emission,  source);
1155       Eina.Error.RaiseIfUnhandledException();
1156                                }
1157    /// <summary>Processes an object&apos;s messages and signals queue.
1158    /// This function goes through the object message queue processing the pending messages for this specific Edje object. Normally they&apos;d be processed only at idle time.
1159    ///
1160    /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
1161    /// 1.21</summary>
1162    /// <param name="recurse">Whether to process messages on children objects.
1163    /// 1.21</param>
1164    /// <returns></returns>
1165    virtual public  void SignalProcess( bool recurse) {
1166                          Efl.Layout.SignalNativeInherit.efl_layout_signal_process_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), recurse);
1167       Eina.Error.RaiseIfUnhandledException();
1168                    }
1169    /// <summary>Whether this object is animating or not.
1170 /// This property indicates whether animations are stopped or not. Animations here refer to transitions between states.
1171 ///
1172 /// If animations are disabled, transitions between states (as defined in EDC) are then instantaneous. This is conceptually similar to setting the <see cref="Efl.Player.PlaySpeed"/> to an infinitely high value.</summary>
1173 /// <value>The animation state, <c>true</c> by default.</value>
1174    public bool Animation {
1175       get { return GetAnimation(); }
1176       set { SetAnimation( value); }
1177    }
1178    /// <summary>Gets the (last) file loading error for a given object.</summary>
1179 /// <value>The load error code.</value>
1180    public Efl.Gfx.ImageLoadError LayoutLoadError {
1181       get { return GetLayoutLoadError(); }
1182    }
1183    /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
1184 /// <value>The handle to an Eina_File that will be used</value>
1185    public Eina.File Mmap {
1186       get { return GetMmap(); }
1187       set { SetMmap( value); }
1188    }
1189    /// <summary>Retrieve the file path from where an object is to fetch the data.
1190 /// You must not modify the strings on the returned pointers.</summary>
1191 /// <value>The file path.</value>
1192    public  System.String File {
1193       get { return GetFile(); }
1194       set { SetFile( value); }
1195    }
1196    /// <summary>Get the previously-set key which corresponds to the target data within a file.
1197 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
1198 ///
1199 /// You must not modify the strings on the returned pointers.</summary>
1200 /// <value>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</value>
1201    public  System.String Key {
1202       get { return GetKey(); }
1203       set { SetKey( value); }
1204    }
1205    /// <summary>Get the load state of the object.</summary>
1206 /// <value>True if the object is loaded, otherwise false.</value>
1207    public bool Loaded {
1208       get { return GetLoaded(); }
1209    }
1210    /// <summary>Whether or not the playable can be played.</summary>
1211 /// <value><c>true</c> if the object have playable data, <c>false</c> otherwise</value>
1212    public bool Playable {
1213       get { return GetPlayable(); }
1214    }
1215    /// <summary>Get play/pause state of the media file.</summary>
1216 /// <value><c>true</c> if playing, <c>false</c> otherwise.</value>
1217    public bool Play {
1218       get { return GetPlay(); }
1219       set { SetPlay( value); }
1220    }
1221    /// <summary>Get the position in the media file.
1222 /// The position is returned as the number of seconds since the beginning of the media file.</summary>
1223 /// <value>The position (in seconds).</value>
1224    public double Pos {
1225       get { return GetPos(); }
1226       set { SetPos( value); }
1227    }
1228    /// <summary>Get how much of the file has been played.
1229 /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
1230 /// <value>The progress within the [0, 1] range.</value>
1231    public double Progress {
1232       get { return GetProgress(); }
1233    }
1234    /// <summary>Control the play speed of the media file.
1235 /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
1236 /// <value>The play speed in the [0, infinity) range.</value>
1237    public double PlaySpeed {
1238       get { return GetPlaySpeed(); }
1239       set { SetPlaySpeed( value); }
1240    }
1241    /// <summary>Control the audio volume.
1242 /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
1243 /// <value>The volume level</value>
1244    public double Volume {
1245       get { return GetVolume(); }
1246       set { SetVolume( value); }
1247    }
1248    /// <summary>This property controls the audio mute state.</summary>
1249 /// <value>The mute state. <c>true</c> or <c>false</c>.</value>
1250    public bool Mute {
1251       get { return GetMute(); }
1252       set { SetMute( value); }
1253    }
1254    /// <summary>Get the length of play for the media file.</summary>
1255 /// <value>The length of the stream in seconds.</value>
1256    public double Length {
1257       get { return GetLength(); }
1258    }
1259    /// <summary>Get whether the media file is seekable.</summary>
1260 /// <value><c>true</c> if seekable.</value>
1261    public bool Seekable {
1262       get { return GetSeekable(); }
1263    }
1264    /// <summary>Whether this object updates its size hints automatically.
1265 /// By default edje doesn&apos;t set size hints on itself. If this property is set to <c>true</c>, size hints will be updated after recalculation. Be careful, as recalculation may happen often, enabling this property may have a considerable performance impact as other widgets will be notified of the size hints changes.
1266 ///
1267 /// A layout recalculation can be triggered by <see cref="Efl.Layout.Calc.CalcSizeMin"/>, <see cref="Efl.Layout.Calc.CalcSizeMin"/>, <see cref="Efl.Layout.Calc.CalcPartsExtends"/> or even any other internal event.
1268 /// 1.21</summary>
1269 /// <value>Whether or not update the size hints.
1270 /// 1.21</value>
1271    public bool CalcAutoUpdateHints {
1272       get { return GetCalcAutoUpdateHints(); }
1273       set { SetCalcAutoUpdateHints( value); }
1274    }
1275    /// <summary>Gets the minimum size specified -- as an EDC property -- for a given Edje object
1276 /// This function retrieves the obj object&apos;s minimum size values, as declared in its EDC group definition. For instance, for an Edje object of minimum size 100x100 pixels: collections { group { name: &quot;a_group&quot;; min: 100 100; } }
1277 ///
1278 /// Note: If the <c>min</c> EDC property was not declared for this object, this call will return 0x0.
1279 ///
1280 /// Note: On failure, this function also return 0x0.
1281 ///
1282 /// See also <see cref="Efl.Layout.Group.GetGroupSizeMax"/>.
1283 /// 1.21</summary>
1284 /// <value>The minimum size as set in EDC.
1285 /// 1.21</value>
1286    public Eina.Size2D GroupSizeMin {
1287       get { return GetGroupSizeMin(); }
1288    }
1289    /// <summary>Gets the maximum size specified -- as an EDC property -- for a given Edje object
1290 /// This function retrieves the object&apos;s maximum size values, as declared in its EDC group definition. For instance, for an Edje object of maximum size 100x100 pixels: collections { group { name: &quot;a_group&quot;; max: 100 100; } }
1291 ///
1292 /// Note: If the <c>max</c> EDC property was not declared for the object, this call will return the maximum size a given Edje object may have, for each axis.
1293 ///
1294 /// Note: On failure, this function will return 0x0.
1295 ///
1296 /// See also <see cref="Efl.Layout.Group.GetGroupSizeMin"/>.
1297 /// 1.21</summary>
1298 /// <value>The maximum size as set in EDC.
1299 /// 1.21</value>
1300    public Eina.Size2D GroupSizeMax {
1301       get { return GetGroupSizeMax(); }
1302    }
1303    private static new  IntPtr GetEflClassStatic()
1304    {
1305       return Efl.Canvas.Layout.efl_canvas_layout_class_get();
1306    }
1307 }
1308 public class LayoutNativeInherit : Efl.Canvas.GroupNativeInherit{
1309    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Edje);
1310    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1311    {
1312       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1313       if (efl_canvas_layout_animation_get_static_delegate == null)
1314       efl_canvas_layout_animation_get_static_delegate = new efl_canvas_layout_animation_get_delegate(animation_get);
1315       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_animation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_animation_get_static_delegate)});
1316       if (efl_canvas_layout_animation_set_static_delegate == null)
1317       efl_canvas_layout_animation_set_static_delegate = new efl_canvas_layout_animation_set_delegate(animation_set);
1318       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_animation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_animation_set_static_delegate)});
1319       if (efl_canvas_layout_seat_get_static_delegate == null)
1320       efl_canvas_layout_seat_get_static_delegate = new efl_canvas_layout_seat_get_delegate(seat_get);
1321       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_seat_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_seat_get_static_delegate)});
1322       if (efl_canvas_layout_seat_name_get_static_delegate == null)
1323       efl_canvas_layout_seat_name_get_static_delegate = new efl_canvas_layout_seat_name_get_delegate(seat_name_get);
1324       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_seat_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_seat_name_get_static_delegate)});
1325       if (efl_canvas_layout_load_error_get_static_delegate == null)
1326       efl_canvas_layout_load_error_get_static_delegate = new efl_canvas_layout_load_error_get_delegate(layout_load_error_get);
1327       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_load_error_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_load_error_get_static_delegate)});
1328       if (efl_canvas_layout_part_text_min_policy_get_static_delegate == null)
1329       efl_canvas_layout_part_text_min_policy_get_static_delegate = new efl_canvas_layout_part_text_min_policy_get_delegate(part_text_min_policy_get);
1330       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_min_policy_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_min_policy_get_static_delegate)});
1331       if (efl_canvas_layout_part_text_min_policy_set_static_delegate == null)
1332       efl_canvas_layout_part_text_min_policy_set_static_delegate = new efl_canvas_layout_part_text_min_policy_set_delegate(part_text_min_policy_set);
1333       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_min_policy_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_min_policy_set_static_delegate)});
1334       if (efl_canvas_layout_part_text_valign_get_static_delegate == null)
1335       efl_canvas_layout_part_text_valign_get_static_delegate = new efl_canvas_layout_part_text_valign_get_delegate(part_text_valign_get);
1336       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_valign_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_valign_get_static_delegate)});
1337       if (efl_canvas_layout_part_text_valign_set_static_delegate == null)
1338       efl_canvas_layout_part_text_valign_set_static_delegate = new efl_canvas_layout_part_text_valign_set_delegate(part_text_valign_set);
1339       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_valign_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_valign_set_static_delegate)});
1340       if (efl_canvas_layout_part_text_marquee_duration_get_static_delegate == null)
1341       efl_canvas_layout_part_text_marquee_duration_get_static_delegate = new efl_canvas_layout_part_text_marquee_duration_get_delegate(part_text_marquee_duration_get);
1342       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_duration_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_duration_get_static_delegate)});
1343       if (efl_canvas_layout_part_text_marquee_duration_set_static_delegate == null)
1344       efl_canvas_layout_part_text_marquee_duration_set_static_delegate = new efl_canvas_layout_part_text_marquee_duration_set_delegate(part_text_marquee_duration_set);
1345       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_duration_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_duration_set_static_delegate)});
1346       if (efl_canvas_layout_part_text_marquee_speed_get_static_delegate == null)
1347       efl_canvas_layout_part_text_marquee_speed_get_static_delegate = new efl_canvas_layout_part_text_marquee_speed_get_delegate(part_text_marquee_speed_get);
1348       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_speed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_speed_get_static_delegate)});
1349       if (efl_canvas_layout_part_text_marquee_speed_set_static_delegate == null)
1350       efl_canvas_layout_part_text_marquee_speed_set_static_delegate = new efl_canvas_layout_part_text_marquee_speed_set_delegate(part_text_marquee_speed_set);
1351       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_speed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_speed_set_static_delegate)});
1352       if (efl_canvas_layout_part_text_marquee_always_get_static_delegate == null)
1353       efl_canvas_layout_part_text_marquee_always_get_static_delegate = new efl_canvas_layout_part_text_marquee_always_get_delegate(part_text_marquee_always_get);
1354       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_always_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_always_get_static_delegate)});
1355       if (efl_canvas_layout_part_text_marquee_always_set_static_delegate == null)
1356       efl_canvas_layout_part_text_marquee_always_set_static_delegate = new efl_canvas_layout_part_text_marquee_always_set_delegate(part_text_marquee_always_set);
1357       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_marquee_always_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_marquee_always_set_static_delegate)});
1358       if (efl_canvas_layout_part_valign_get_static_delegate == null)
1359       efl_canvas_layout_part_valign_get_static_delegate = new efl_canvas_layout_part_valign_get_delegate(part_valign_get);
1360       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_valign_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_valign_get_static_delegate)});
1361       if (efl_canvas_layout_part_valign_set_static_delegate == null)
1362       efl_canvas_layout_part_valign_set_static_delegate = new efl_canvas_layout_part_valign_set_delegate(part_valign_set);
1363       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_valign_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_valign_set_static_delegate)});
1364       if (efl_canvas_layout_access_part_iterate_static_delegate == null)
1365       efl_canvas_layout_access_part_iterate_static_delegate = new efl_canvas_layout_access_part_iterate_delegate(access_part_iterate);
1366       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_access_part_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_access_part_iterate_static_delegate)});
1367       if (efl_canvas_layout_content_remove_static_delegate == null)
1368       efl_canvas_layout_content_remove_static_delegate = new efl_canvas_layout_content_remove_delegate(content_remove);
1369       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_content_remove"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_content_remove_static_delegate)});
1370       if (efl_canvas_layout_color_class_parent_set_static_delegate == null)
1371       efl_canvas_layout_color_class_parent_set_static_delegate = new efl_canvas_layout_color_class_parent_set_delegate(color_class_parent_set);
1372       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_color_class_parent_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_color_class_parent_set_static_delegate)});
1373       if (efl_canvas_layout_color_class_parent_unset_static_delegate == null)
1374       efl_canvas_layout_color_class_parent_unset_static_delegate = new efl_canvas_layout_color_class_parent_unset_delegate(color_class_parent_unset);
1375       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_color_class_parent_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_color_class_parent_unset_static_delegate)});
1376       if (efl_canvas_layout_part_text_cursor_coord_get_static_delegate == null)
1377       efl_canvas_layout_part_text_cursor_coord_get_static_delegate = new efl_canvas_layout_part_text_cursor_coord_get_delegate(part_text_cursor_coord_get);
1378       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_cursor_coord_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_cursor_coord_get_static_delegate)});
1379       if (efl_canvas_layout_part_text_cursor_size_get_static_delegate == null)
1380       efl_canvas_layout_part_text_cursor_size_get_static_delegate = new efl_canvas_layout_part_text_cursor_size_get_delegate(part_text_cursor_size_get);
1381       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_cursor_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_cursor_size_get_static_delegate)});
1382       if (efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_static_delegate == null)
1383       efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_static_delegate = new efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_delegate(part_text_cursor_on_mouse_geometry_get);
1384       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_layout_part_text_cursor_on_mouse_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_static_delegate)});
1385       if (efl_content_iterate_static_delegate == null)
1386       efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
1387       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_content_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_content_iterate_static_delegate)});
1388       if (efl_content_count_static_delegate == null)
1389       efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
1390       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_content_count"), func = Marshal.GetFunctionPointerForDelegate(efl_content_count_static_delegate)});
1391       if (efl_file_mmap_get_static_delegate == null)
1392       efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
1393       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate)});
1394       if (efl_file_mmap_set_static_delegate == null)
1395       efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
1396       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate)});
1397       if (efl_file_get_static_delegate == null)
1398       efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
1399       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate)});
1400       if (efl_file_set_static_delegate == null)
1401       efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
1402       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate)});
1403       if (efl_file_key_get_static_delegate == null)
1404       efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
1405       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate)});
1406       if (efl_file_key_set_static_delegate == null)
1407       efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
1408       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate)});
1409       if (efl_file_loaded_get_static_delegate == null)
1410       efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
1411       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate)});
1412       if (efl_file_load_static_delegate == null)
1413       efl_file_load_static_delegate = new efl_file_load_delegate(load);
1414       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate)});
1415       if (efl_file_unload_static_delegate == null)
1416       efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
1417       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate)});
1418       if (efl_observer_update_static_delegate == null)
1419       efl_observer_update_static_delegate = new efl_observer_update_delegate(update);
1420       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_observer_update"), func = Marshal.GetFunctionPointerForDelegate(efl_observer_update_static_delegate)});
1421       if (efl_part_get_static_delegate == null)
1422       efl_part_get_static_delegate = new efl_part_get_delegate(part_get);
1423       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_part_get"), func = Marshal.GetFunctionPointerForDelegate(efl_part_get_static_delegate)});
1424       if (efl_player_playable_get_static_delegate == null)
1425       efl_player_playable_get_static_delegate = new efl_player_playable_get_delegate(playable_get);
1426       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_playable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_playable_get_static_delegate)});
1427       if (efl_player_play_get_static_delegate == null)
1428       efl_player_play_get_static_delegate = new efl_player_play_get_delegate(play_get);
1429       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_play_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_get_static_delegate)});
1430       if (efl_player_play_set_static_delegate == null)
1431       efl_player_play_set_static_delegate = new efl_player_play_set_delegate(play_set);
1432       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_play_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_set_static_delegate)});
1433       if (efl_player_pos_get_static_delegate == null)
1434       efl_player_pos_get_static_delegate = new efl_player_pos_get_delegate(pos_get);
1435       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_pos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_pos_get_static_delegate)});
1436       if (efl_player_pos_set_static_delegate == null)
1437       efl_player_pos_set_static_delegate = new efl_player_pos_set_delegate(pos_set);
1438       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_pos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_pos_set_static_delegate)});
1439       if (efl_player_progress_get_static_delegate == null)
1440       efl_player_progress_get_static_delegate = new efl_player_progress_get_delegate(progress_get);
1441       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_progress_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_progress_get_static_delegate)});
1442       if (efl_player_play_speed_get_static_delegate == null)
1443       efl_player_play_speed_get_static_delegate = new efl_player_play_speed_get_delegate(play_speed_get);
1444       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_play_speed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_speed_get_static_delegate)});
1445       if (efl_player_play_speed_set_static_delegate == null)
1446       efl_player_play_speed_set_static_delegate = new efl_player_play_speed_set_delegate(play_speed_set);
1447       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_play_speed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_speed_set_static_delegate)});
1448       if (efl_player_volume_get_static_delegate == null)
1449       efl_player_volume_get_static_delegate = new efl_player_volume_get_delegate(volume_get);
1450       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_volume_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_volume_get_static_delegate)});
1451       if (efl_player_volume_set_static_delegate == null)
1452       efl_player_volume_set_static_delegate = new efl_player_volume_set_delegate(volume_set);
1453       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_volume_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_volume_set_static_delegate)});
1454       if (efl_player_mute_get_static_delegate == null)
1455       efl_player_mute_get_static_delegate = new efl_player_mute_get_delegate(mute_get);
1456       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_mute_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_mute_get_static_delegate)});
1457       if (efl_player_mute_set_static_delegate == null)
1458       efl_player_mute_set_static_delegate = new efl_player_mute_set_delegate(mute_set);
1459       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_mute_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_mute_set_static_delegate)});
1460       if (efl_player_length_get_static_delegate == null)
1461       efl_player_length_get_static_delegate = new efl_player_length_get_delegate(length_get);
1462       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_length_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_length_get_static_delegate)});
1463       if (efl_player_seekable_get_static_delegate == null)
1464       efl_player_seekable_get_static_delegate = new efl_player_seekable_get_delegate(seekable_get);
1465       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_seekable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_seekable_get_static_delegate)});
1466       if (efl_player_start_static_delegate == null)
1467       efl_player_start_static_delegate = new efl_player_start_delegate(start);
1468       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_start"), func = Marshal.GetFunctionPointerForDelegate(efl_player_start_static_delegate)});
1469       if (efl_player_stop_static_delegate == null)
1470       efl_player_stop_static_delegate = new efl_player_stop_delegate(stop);
1471       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_player_stop"), func = Marshal.GetFunctionPointerForDelegate(efl_player_stop_static_delegate)});
1472       if (efl_gfx_color_class_get_static_delegate == null)
1473       efl_gfx_color_class_get_static_delegate = new efl_gfx_color_class_get_delegate(color_class_get);
1474       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_get_static_delegate)});
1475       if (efl_gfx_color_class_set_static_delegate == null)
1476       efl_gfx_color_class_set_static_delegate = new efl_gfx_color_class_set_delegate(color_class_set);
1477       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_set_static_delegate)});
1478       if (efl_gfx_color_class_code_get_static_delegate == null)
1479       efl_gfx_color_class_code_get_static_delegate = new efl_gfx_color_class_code_get_delegate(color_class_code_get);
1480       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_code_get_static_delegate)});
1481       if (efl_gfx_color_class_code_set_static_delegate == null)
1482       efl_gfx_color_class_code_set_static_delegate = new efl_gfx_color_class_code_set_delegate(color_class_code_set);
1483       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_code_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_code_set_static_delegate)});
1484       if (efl_gfx_color_class_description_get_static_delegate == null)
1485       efl_gfx_color_class_description_get_static_delegate = new efl_gfx_color_class_description_get_delegate(color_class_description_get);
1486       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_description_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_description_get_static_delegate)});
1487       if (efl_gfx_color_class_del_static_delegate == null)
1488       efl_gfx_color_class_del_static_delegate = new efl_gfx_color_class_del_delegate(color_class_del);
1489       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_del"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_del_static_delegate)});
1490       if (efl_gfx_color_class_clear_static_delegate == null)
1491       efl_gfx_color_class_clear_static_delegate = new efl_gfx_color_class_clear_delegate(color_class_clear);
1492       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_class_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_class_clear_static_delegate)});
1493       if (efl_gfx_size_class_get_static_delegate == null)
1494       efl_gfx_size_class_get_static_delegate = new efl_gfx_size_class_get_delegate(size_class_get);
1495       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_size_class_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_size_class_get_static_delegate)});
1496       if (efl_gfx_size_class_set_static_delegate == null)
1497       efl_gfx_size_class_set_static_delegate = new efl_gfx_size_class_set_delegate(size_class_set);
1498       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_size_class_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_size_class_set_static_delegate)});
1499       if (efl_gfx_size_class_del_static_delegate == null)
1500       efl_gfx_size_class_del_static_delegate = new efl_gfx_size_class_del_delegate(size_class_del);
1501       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_size_class_del"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_size_class_del_static_delegate)});
1502       if (efl_gfx_text_class_get_static_delegate == null)
1503       efl_gfx_text_class_get_static_delegate = new efl_gfx_text_class_get_delegate(text_class_get);
1504       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_text_class_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_text_class_get_static_delegate)});
1505       if (efl_gfx_text_class_set_static_delegate == null)
1506       efl_gfx_text_class_set_static_delegate = new efl_gfx_text_class_set_delegate(text_class_set);
1507       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_text_class_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_text_class_set_static_delegate)});
1508       if (efl_gfx_text_class_del_static_delegate == null)
1509       efl_gfx_text_class_del_static_delegate = new efl_gfx_text_class_del_delegate(text_class_del);
1510       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_text_class_del"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_text_class_del_static_delegate)});
1511       if (efl_layout_calc_auto_update_hints_get_static_delegate == null)
1512       efl_layout_calc_auto_update_hints_get_static_delegate = new efl_layout_calc_auto_update_hints_get_delegate(calc_auto_update_hints_get);
1513       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_auto_update_hints_get"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_auto_update_hints_get_static_delegate)});
1514       if (efl_layout_calc_auto_update_hints_set_static_delegate == null)
1515       efl_layout_calc_auto_update_hints_set_static_delegate = new efl_layout_calc_auto_update_hints_set_delegate(calc_auto_update_hints_set);
1516       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_auto_update_hints_set"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_auto_update_hints_set_static_delegate)});
1517       if (efl_layout_calc_size_min_static_delegate == null)
1518       efl_layout_calc_size_min_static_delegate = new efl_layout_calc_size_min_delegate(calc_size_min);
1519       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_size_min"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_size_min_static_delegate)});
1520       if (efl_layout_calc_parts_extends_static_delegate == null)
1521       efl_layout_calc_parts_extends_static_delegate = new efl_layout_calc_parts_extends_delegate(calc_parts_extends);
1522       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_parts_extends"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_parts_extends_static_delegate)});
1523       if (efl_layout_calc_freeze_static_delegate == null)
1524       efl_layout_calc_freeze_static_delegate = new efl_layout_calc_freeze_delegate(calc_freeze);
1525       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_freeze"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_freeze_static_delegate)});
1526       if (efl_layout_calc_thaw_static_delegate == null)
1527       efl_layout_calc_thaw_static_delegate = new efl_layout_calc_thaw_delegate(calc_thaw);
1528       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_thaw"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_thaw_static_delegate)});
1529       if (efl_layout_calc_force_static_delegate == null)
1530       efl_layout_calc_force_static_delegate = new efl_layout_calc_force_delegate(calc_force);
1531       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_calc_force"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_calc_force_static_delegate)});
1532       if (efl_layout_group_size_min_get_static_delegate == null)
1533       efl_layout_group_size_min_get_static_delegate = new efl_layout_group_size_min_get_delegate(group_size_min_get);
1534       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_group_size_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_group_size_min_get_static_delegate)});
1535       if (efl_layout_group_size_max_get_static_delegate == null)
1536       efl_layout_group_size_max_get_static_delegate = new efl_layout_group_size_max_get_delegate(group_size_max_get);
1537       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_group_size_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_group_size_max_get_static_delegate)});
1538       if (efl_layout_group_data_get_static_delegate == null)
1539       efl_layout_group_data_get_static_delegate = new efl_layout_group_data_get_delegate(group_data_get);
1540       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_group_data_get"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_group_data_get_static_delegate)});
1541       if (efl_layout_group_part_exist_get_static_delegate == null)
1542       efl_layout_group_part_exist_get_static_delegate = new efl_layout_group_part_exist_get_delegate(part_exist_get);
1543       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_group_part_exist_get"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_group_part_exist_get_static_delegate)});
1544       if (efl_layout_signal_message_send_static_delegate == null)
1545       efl_layout_signal_message_send_static_delegate = new efl_layout_signal_message_send_delegate(message_send);
1546       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_message_send"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_message_send_static_delegate)});
1547       if (efl_layout_signal_callback_add_static_delegate == null)
1548       efl_layout_signal_callback_add_static_delegate = new efl_layout_signal_callback_add_delegate(signal_callback_add);
1549       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_callback_add"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_callback_add_static_delegate)});
1550       if (efl_layout_signal_callback_del_static_delegate == null)
1551       efl_layout_signal_callback_del_static_delegate = new efl_layout_signal_callback_del_delegate(signal_callback_del);
1552       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_callback_del"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_callback_del_static_delegate)});
1553       if (efl_layout_signal_emit_static_delegate == null)
1554       efl_layout_signal_emit_static_delegate = new efl_layout_signal_emit_delegate(signal_emit);
1555       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_emit"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_emit_static_delegate)});
1556       if (efl_layout_signal_process_static_delegate == null)
1557       efl_layout_signal_process_static_delegate = new efl_layout_signal_process_delegate(signal_process);
1558       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_process"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_process_static_delegate)});
1559       descs.AddRange(base.GetEoOps(type));
1560       return descs;
1561    }
1562    public override IntPtr GetEflClass()
1563    {
1564       return Efl.Canvas.Layout.efl_canvas_layout_class_get();
1565    }
1566    public static new  IntPtr GetEflClassStatic()
1567    {
1568       return Efl.Canvas.Layout.efl_canvas_layout_class_get();
1569    }
1570
1571
1572     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_animation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1573
1574
1575     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_animation_get_api_delegate(System.IntPtr obj);
1576     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_animation_get_api_delegate> efl_canvas_layout_animation_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_animation_get_api_delegate>(_Module, "efl_canvas_layout_animation_get");
1577     private static bool animation_get(System.IntPtr obj, System.IntPtr pd)
1578    {
1579       Eina.Log.Debug("function efl_canvas_layout_animation_get was called");
1580       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1581       if(wrapper != null) {
1582                   bool _ret_var = default(bool);
1583          try {
1584             _ret_var = ((Layout)wrapper).GetAnimation();
1585          } catch (Exception e) {
1586             Eina.Log.Warning($"Callback error: {e.ToString()}");
1587             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1588          }
1589       return _ret_var;
1590       } else {
1591          return efl_canvas_layout_animation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1592       }
1593    }
1594    private static efl_canvas_layout_animation_get_delegate efl_canvas_layout_animation_get_static_delegate;
1595
1596
1597     private delegate  void efl_canvas_layout_animation_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool on);
1598
1599
1600     public delegate  void efl_canvas_layout_animation_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool on);
1601     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_animation_set_api_delegate> efl_canvas_layout_animation_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_animation_set_api_delegate>(_Module, "efl_canvas_layout_animation_set");
1602     private static  void animation_set(System.IntPtr obj, System.IntPtr pd,  bool on)
1603    {
1604       Eina.Log.Debug("function efl_canvas_layout_animation_set was called");
1605       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1606       if(wrapper != null) {
1607
1608          try {
1609             ((Layout)wrapper).SetAnimation( on);
1610          } catch (Exception e) {
1611             Eina.Log.Warning($"Callback error: {e.ToString()}");
1612             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1613          }
1614                         } else {
1615          efl_canvas_layout_animation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  on);
1616       }
1617    }
1618    private static efl_canvas_layout_animation_set_delegate efl_canvas_layout_animation_set_static_delegate;
1619
1620
1621    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] private delegate Efl.Input.Device efl_canvas_layout_seat_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))]   System.String name);
1622
1623
1624    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] public delegate Efl.Input.Device efl_canvas_layout_seat_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))]   System.String name);
1625     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_seat_get_api_delegate> efl_canvas_layout_seat_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_seat_get_api_delegate>(_Module, "efl_canvas_layout_seat_get");
1626     private static Efl.Input.Device seat_get(System.IntPtr obj, System.IntPtr pd,   System.String name)
1627    {
1628       Eina.Log.Debug("function efl_canvas_layout_seat_get was called");
1629       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1630       if(wrapper != null) {
1631                                     Efl.Input.Device _ret_var = default(Efl.Input.Device);
1632          try {
1633             _ret_var = ((Layout)wrapper).GetSeat( name);
1634          } catch (Exception e) {
1635             Eina.Log.Warning($"Callback error: {e.ToString()}");
1636             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1637          }
1638                   return _ret_var;
1639       } else {
1640          return efl_canvas_layout_seat_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name);
1641       }
1642    }
1643    private static efl_canvas_layout_seat_get_delegate efl_canvas_layout_seat_get_static_delegate;
1644
1645
1646     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))] private delegate  System.String efl_canvas_layout_seat_name_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))]  Efl.Input.Device device);
1647
1648
1649     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))] public delegate  System.String efl_canvas_layout_seat_name_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))]  Efl.Input.Device device);
1650     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_seat_name_get_api_delegate> efl_canvas_layout_seat_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_seat_name_get_api_delegate>(_Module, "efl_canvas_layout_seat_name_get");
1651     private static  System.String seat_name_get(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Device device)
1652    {
1653       Eina.Log.Debug("function efl_canvas_layout_seat_name_get was called");
1654       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1655       if(wrapper != null) {
1656                                      System.String _ret_var = default( System.String);
1657          try {
1658             _ret_var = ((Layout)wrapper).GetSeatName( device);
1659          } catch (Exception e) {
1660             Eina.Log.Warning($"Callback error: {e.ToString()}");
1661             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1662          }
1663                   return _ret_var;
1664       } else {
1665          return efl_canvas_layout_seat_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  device);
1666       }
1667    }
1668    private static efl_canvas_layout_seat_name_get_delegate efl_canvas_layout_seat_name_get_static_delegate;
1669
1670
1671     private delegate Efl.Gfx.ImageLoadError efl_canvas_layout_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
1672
1673
1674     public delegate Efl.Gfx.ImageLoadError efl_canvas_layout_load_error_get_api_delegate(System.IntPtr obj);
1675     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_load_error_get_api_delegate> efl_canvas_layout_load_error_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_load_error_get_api_delegate>(_Module, "efl_canvas_layout_load_error_get");
1676     private static Efl.Gfx.ImageLoadError layout_load_error_get(System.IntPtr obj, System.IntPtr pd)
1677    {
1678       Eina.Log.Debug("function efl_canvas_layout_load_error_get was called");
1679       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1680       if(wrapper != null) {
1681                   Efl.Gfx.ImageLoadError _ret_var = default(Efl.Gfx.ImageLoadError);
1682          try {
1683             _ret_var = ((Layout)wrapper).GetLayoutLoadError();
1684          } catch (Exception e) {
1685             Eina.Log.Warning($"Callback error: {e.ToString()}");
1686             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1687          }
1688       return _ret_var;
1689       } else {
1690          return efl_canvas_layout_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1691       }
1692    }
1693    private static efl_canvas_layout_load_error_get_delegate efl_canvas_layout_load_error_get_static_delegate;
1694
1695
1696     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_min_policy_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String state_name,  [MarshalAs(UnmanagedType.U1)]  out bool min_x,  [MarshalAs(UnmanagedType.U1)]  out bool min_y);
1697
1698
1699     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_min_policy_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String state_name,  [MarshalAs(UnmanagedType.U1)]  out bool min_x,  [MarshalAs(UnmanagedType.U1)]  out bool min_y);
1700     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_min_policy_get_api_delegate> efl_canvas_layout_part_text_min_policy_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_min_policy_get_api_delegate>(_Module, "efl_canvas_layout_part_text_min_policy_get");
1701     private static bool part_text_min_policy_get(System.IntPtr obj, System.IntPtr pd,   System.String part,   System.String state_name,  out bool min_x,  out bool min_y)
1702    {
1703       Eina.Log.Debug("function efl_canvas_layout_part_text_min_policy_get was called");
1704       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1705       if(wrapper != null) {
1706                                                    min_x = default(bool);      min_y = default(bool);                                 bool _ret_var = default(bool);
1707          try {
1708             _ret_var = ((Layout)wrapper).GetPartTextMinPolicy( part,  state_name,  out min_x,  out min_y);
1709          } catch (Exception e) {
1710             Eina.Log.Warning($"Callback error: {e.ToString()}");
1711             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1712          }
1713                                                       return _ret_var;
1714       } else {
1715          return efl_canvas_layout_part_text_min_policy_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  state_name,  out min_x,  out min_y);
1716       }
1717    }
1718    private static efl_canvas_layout_part_text_min_policy_get_delegate efl_canvas_layout_part_text_min_policy_get_static_delegate;
1719
1720
1721     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_min_policy_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String state_name,  [MarshalAs(UnmanagedType.U1)]  bool min_x,  [MarshalAs(UnmanagedType.U1)]  bool min_y);
1722
1723
1724     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_min_policy_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String state_name,  [MarshalAs(UnmanagedType.U1)]  bool min_x,  [MarshalAs(UnmanagedType.U1)]  bool min_y);
1725     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_min_policy_set_api_delegate> efl_canvas_layout_part_text_min_policy_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_min_policy_set_api_delegate>(_Module, "efl_canvas_layout_part_text_min_policy_set");
1726     private static bool part_text_min_policy_set(System.IntPtr obj, System.IntPtr pd,   System.String part,   System.String state_name,  bool min_x,  bool min_y)
1727    {
1728       Eina.Log.Debug("function efl_canvas_layout_part_text_min_policy_set was called");
1729       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1730       if(wrapper != null) {
1731                                                                                           bool _ret_var = default(bool);
1732          try {
1733             _ret_var = ((Layout)wrapper).SetPartTextMinPolicy( part,  state_name,  min_x,  min_y);
1734          } catch (Exception e) {
1735             Eina.Log.Warning($"Callback error: {e.ToString()}");
1736             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1737          }
1738                                                       return _ret_var;
1739       } else {
1740          return efl_canvas_layout_part_text_min_policy_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  state_name,  min_x,  min_y);
1741       }
1742    }
1743    private static efl_canvas_layout_part_text_min_policy_set_delegate efl_canvas_layout_part_text_min_policy_set_static_delegate;
1744
1745
1746     private delegate double efl_canvas_layout_part_text_valign_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1747
1748
1749     public delegate double efl_canvas_layout_part_text_valign_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1750     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_valign_get_api_delegate> efl_canvas_layout_part_text_valign_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_valign_get_api_delegate>(_Module, "efl_canvas_layout_part_text_valign_get");
1751     private static double part_text_valign_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
1752    {
1753       Eina.Log.Debug("function efl_canvas_layout_part_text_valign_get was called");
1754       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1755       if(wrapper != null) {
1756                                     double _ret_var = default(double);
1757          try {
1758             _ret_var = ((Layout)wrapper).GetPartTextValign( part);
1759          } catch (Exception e) {
1760             Eina.Log.Warning($"Callback error: {e.ToString()}");
1761             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1762          }
1763                   return _ret_var;
1764       } else {
1765          return efl_canvas_layout_part_text_valign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
1766       }
1767    }
1768    private static efl_canvas_layout_part_text_valign_get_delegate efl_canvas_layout_part_text_valign_get_static_delegate;
1769
1770
1771     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_valign_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double valign);
1772
1773
1774     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_valign_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double valign);
1775     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_valign_set_api_delegate> efl_canvas_layout_part_text_valign_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_valign_set_api_delegate>(_Module, "efl_canvas_layout_part_text_valign_set");
1776     private static bool part_text_valign_set(System.IntPtr obj, System.IntPtr pd,   System.String part,  double valign)
1777    {
1778       Eina.Log.Debug("function efl_canvas_layout_part_text_valign_set was called");
1779       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1780       if(wrapper != null) {
1781                                                       bool _ret_var = default(bool);
1782          try {
1783             _ret_var = ((Layout)wrapper).SetPartTextValign( part,  valign);
1784          } catch (Exception e) {
1785             Eina.Log.Warning($"Callback error: {e.ToString()}");
1786             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1787          }
1788                               return _ret_var;
1789       } else {
1790          return efl_canvas_layout_part_text_valign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  valign);
1791       }
1792    }
1793    private static efl_canvas_layout_part_text_valign_set_delegate efl_canvas_layout_part_text_valign_set_static_delegate;
1794
1795
1796     private delegate double efl_canvas_layout_part_text_marquee_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1797
1798
1799     public delegate double efl_canvas_layout_part_text_marquee_duration_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1800     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_duration_get_api_delegate> efl_canvas_layout_part_text_marquee_duration_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_duration_get_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_duration_get");
1801     private static double part_text_marquee_duration_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
1802    {
1803       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_duration_get was called");
1804       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1805       if(wrapper != null) {
1806                                     double _ret_var = default(double);
1807          try {
1808             _ret_var = ((Layout)wrapper).GetPartTextMarqueeDuration( part);
1809          } catch (Exception e) {
1810             Eina.Log.Warning($"Callback error: {e.ToString()}");
1811             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1812          }
1813                   return _ret_var;
1814       } else {
1815          return efl_canvas_layout_part_text_marquee_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
1816       }
1817    }
1818    private static efl_canvas_layout_part_text_marquee_duration_get_delegate efl_canvas_layout_part_text_marquee_duration_get_static_delegate;
1819
1820
1821     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_marquee_duration_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double duration);
1822
1823
1824     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_marquee_duration_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double duration);
1825     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_duration_set_api_delegate> efl_canvas_layout_part_text_marquee_duration_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_duration_set_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_duration_set");
1826     private static bool part_text_marquee_duration_set(System.IntPtr obj, System.IntPtr pd,   System.String part,  double duration)
1827    {
1828       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_duration_set was called");
1829       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1830       if(wrapper != null) {
1831                                                       bool _ret_var = default(bool);
1832          try {
1833             _ret_var = ((Layout)wrapper).SetPartTextMarqueeDuration( part,  duration);
1834          } catch (Exception e) {
1835             Eina.Log.Warning($"Callback error: {e.ToString()}");
1836             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1837          }
1838                               return _ret_var;
1839       } else {
1840          return efl_canvas_layout_part_text_marquee_duration_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  duration);
1841       }
1842    }
1843    private static efl_canvas_layout_part_text_marquee_duration_set_delegate efl_canvas_layout_part_text_marquee_duration_set_static_delegate;
1844
1845
1846     private delegate double efl_canvas_layout_part_text_marquee_speed_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1847
1848
1849     public delegate double efl_canvas_layout_part_text_marquee_speed_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1850     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_speed_get_api_delegate> efl_canvas_layout_part_text_marquee_speed_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_speed_get_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_speed_get");
1851     private static double part_text_marquee_speed_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
1852    {
1853       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_speed_get was called");
1854       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1855       if(wrapper != null) {
1856                                     double _ret_var = default(double);
1857          try {
1858             _ret_var = ((Layout)wrapper).GetPartTextMarqueeSpeed( part);
1859          } catch (Exception e) {
1860             Eina.Log.Warning($"Callback error: {e.ToString()}");
1861             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1862          }
1863                   return _ret_var;
1864       } else {
1865          return efl_canvas_layout_part_text_marquee_speed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
1866       }
1867    }
1868    private static efl_canvas_layout_part_text_marquee_speed_get_delegate efl_canvas_layout_part_text_marquee_speed_get_static_delegate;
1869
1870
1871     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_marquee_speed_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double speed);
1872
1873
1874     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_marquee_speed_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double speed);
1875     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_speed_set_api_delegate> efl_canvas_layout_part_text_marquee_speed_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_speed_set_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_speed_set");
1876     private static bool part_text_marquee_speed_set(System.IntPtr obj, System.IntPtr pd,   System.String part,  double speed)
1877    {
1878       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_speed_set was called");
1879       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1880       if(wrapper != null) {
1881                                                       bool _ret_var = default(bool);
1882          try {
1883             _ret_var = ((Layout)wrapper).SetPartTextMarqueeSpeed( part,  speed);
1884          } catch (Exception e) {
1885             Eina.Log.Warning($"Callback error: {e.ToString()}");
1886             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1887          }
1888                               return _ret_var;
1889       } else {
1890          return efl_canvas_layout_part_text_marquee_speed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  speed);
1891       }
1892    }
1893    private static efl_canvas_layout_part_text_marquee_speed_set_delegate efl_canvas_layout_part_text_marquee_speed_set_static_delegate;
1894
1895
1896     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_marquee_always_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1897
1898
1899     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_marquee_always_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1900     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_always_get_api_delegate> efl_canvas_layout_part_text_marquee_always_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_always_get_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_always_get");
1901     private static bool part_text_marquee_always_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
1902    {
1903       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_always_get was called");
1904       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1905       if(wrapper != null) {
1906                                     bool _ret_var = default(bool);
1907          try {
1908             _ret_var = ((Layout)wrapper).GetPartTextMarqueeAlways( part);
1909          } catch (Exception e) {
1910             Eina.Log.Warning($"Callback error: {e.ToString()}");
1911             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1912          }
1913                   return _ret_var;
1914       } else {
1915          return efl_canvas_layout_part_text_marquee_always_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
1916       }
1917    }
1918    private static efl_canvas_layout_part_text_marquee_always_get_delegate efl_canvas_layout_part_text_marquee_always_get_static_delegate;
1919
1920
1921     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_text_marquee_always_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.U1)]  bool always);
1922
1923
1924     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_text_marquee_always_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,  [MarshalAs(UnmanagedType.U1)]  bool always);
1925     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_always_set_api_delegate> efl_canvas_layout_part_text_marquee_always_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_marquee_always_set_api_delegate>(_Module, "efl_canvas_layout_part_text_marquee_always_set");
1926     private static bool part_text_marquee_always_set(System.IntPtr obj, System.IntPtr pd,   System.String part,  bool always)
1927    {
1928       Eina.Log.Debug("function efl_canvas_layout_part_text_marquee_always_set was called");
1929       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1930       if(wrapper != null) {
1931                                                       bool _ret_var = default(bool);
1932          try {
1933             _ret_var = ((Layout)wrapper).SetPartTextMarqueeAlways( part,  always);
1934          } catch (Exception e) {
1935             Eina.Log.Warning($"Callback error: {e.ToString()}");
1936             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1937          }
1938                               return _ret_var;
1939       } else {
1940          return efl_canvas_layout_part_text_marquee_always_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  always);
1941       }
1942    }
1943    private static efl_canvas_layout_part_text_marquee_always_set_delegate efl_canvas_layout_part_text_marquee_always_set_static_delegate;
1944
1945
1946     private delegate double efl_canvas_layout_part_valign_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1947
1948
1949     public delegate double efl_canvas_layout_part_valign_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
1950     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_valign_get_api_delegate> efl_canvas_layout_part_valign_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_valign_get_api_delegate>(_Module, "efl_canvas_layout_part_valign_get");
1951     private static double part_valign_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
1952    {
1953       Eina.Log.Debug("function efl_canvas_layout_part_valign_get was called");
1954       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1955       if(wrapper != null) {
1956                                     double _ret_var = default(double);
1957          try {
1958             _ret_var = ((Layout)wrapper).GetPartValign( part);
1959          } catch (Exception e) {
1960             Eina.Log.Warning($"Callback error: {e.ToString()}");
1961             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1962          }
1963                   return _ret_var;
1964       } else {
1965          return efl_canvas_layout_part_valign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
1966       }
1967    }
1968    private static efl_canvas_layout_part_valign_get_delegate efl_canvas_layout_part_valign_get_static_delegate;
1969
1970
1971     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_part_valign_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double valign);
1972
1973
1974     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_part_valign_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   double valign);
1975     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_valign_set_api_delegate> efl_canvas_layout_part_valign_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_valign_set_api_delegate>(_Module, "efl_canvas_layout_part_valign_set");
1976     private static bool part_valign_set(System.IntPtr obj, System.IntPtr pd,   System.String part,  double valign)
1977    {
1978       Eina.Log.Debug("function efl_canvas_layout_part_valign_set was called");
1979       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1980       if(wrapper != null) {
1981                                                       bool _ret_var = default(bool);
1982          try {
1983             _ret_var = ((Layout)wrapper).SetPartValign( part,  valign);
1984          } catch (Exception e) {
1985             Eina.Log.Warning($"Callback error: {e.ToString()}");
1986             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1987          }
1988                               return _ret_var;
1989       } else {
1990          return efl_canvas_layout_part_valign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  valign);
1991       }
1992    }
1993    private static efl_canvas_layout_part_valign_set_delegate efl_canvas_layout_part_valign_set_static_delegate;
1994
1995
1996     private delegate  System.IntPtr efl_canvas_layout_access_part_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
1997
1998
1999     public delegate  System.IntPtr efl_canvas_layout_access_part_iterate_api_delegate(System.IntPtr obj);
2000     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_access_part_iterate_api_delegate> efl_canvas_layout_access_part_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_access_part_iterate_api_delegate>(_Module, "efl_canvas_layout_access_part_iterate");
2001     private static  System.IntPtr access_part_iterate(System.IntPtr obj, System.IntPtr pd)
2002    {
2003       Eina.Log.Debug("function efl_canvas_layout_access_part_iterate was called");
2004       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2005       if(wrapper != null) {
2006                   Eina.Iterator< System.String> _ret_var = default(Eina.Iterator< System.String>);
2007          try {
2008             _ret_var = ((Layout)wrapper).AccessPartIterate();
2009          } catch (Exception e) {
2010             Eina.Log.Warning($"Callback error: {e.ToString()}");
2011             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2012          }
2013       _ret_var.Own = false; return _ret_var.Handle;
2014       } else {
2015          return efl_canvas_layout_access_part_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2016       }
2017    }
2018    private static efl_canvas_layout_access_part_iterate_delegate efl_canvas_layout_access_part_iterate_static_delegate;
2019
2020
2021     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_canvas_layout_content_remove_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity content);
2022
2023
2024     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_canvas_layout_content_remove_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity content);
2025     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_content_remove_api_delegate> efl_canvas_layout_content_remove_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_content_remove_api_delegate>(_Module, "efl_canvas_layout_content_remove");
2026     private static bool content_remove(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity content)
2027    {
2028       Eina.Log.Debug("function efl_canvas_layout_content_remove was called");
2029       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2030       if(wrapper != null) {
2031                                     bool _ret_var = default(bool);
2032          try {
2033             _ret_var = ((Layout)wrapper).ContentRemove( content);
2034          } catch (Exception e) {
2035             Eina.Log.Warning($"Callback error: {e.ToString()}");
2036             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2037          }
2038                   return _ret_var;
2039       } else {
2040          return efl_canvas_layout_content_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  content);
2041       }
2042    }
2043    private static efl_canvas_layout_content_remove_delegate efl_canvas_layout_content_remove_static_delegate;
2044
2045
2046     private delegate  void efl_canvas_layout_color_class_parent_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object parent);
2047
2048
2049     public delegate  void efl_canvas_layout_color_class_parent_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object parent);
2050     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_color_class_parent_set_api_delegate> efl_canvas_layout_color_class_parent_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_color_class_parent_set_api_delegate>(_Module, "efl_canvas_layout_color_class_parent_set");
2051     private static  void color_class_parent_set(System.IntPtr obj, System.IntPtr pd,  Efl.Object parent)
2052    {
2053       Eina.Log.Debug("function efl_canvas_layout_color_class_parent_set was called");
2054       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2055       if(wrapper != null) {
2056
2057          try {
2058             ((Layout)wrapper).SetColorClassParent( parent);
2059          } catch (Exception e) {
2060             Eina.Log.Warning($"Callback error: {e.ToString()}");
2061             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2062          }
2063                         } else {
2064          efl_canvas_layout_color_class_parent_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  parent);
2065       }
2066    }
2067    private static efl_canvas_layout_color_class_parent_set_delegate efl_canvas_layout_color_class_parent_set_static_delegate;
2068
2069
2070     private delegate  void efl_canvas_layout_color_class_parent_unset_delegate(System.IntPtr obj, System.IntPtr pd);
2071
2072
2073     public delegate  void efl_canvas_layout_color_class_parent_unset_api_delegate(System.IntPtr obj);
2074     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_color_class_parent_unset_api_delegate> efl_canvas_layout_color_class_parent_unset_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_color_class_parent_unset_api_delegate>(_Module, "efl_canvas_layout_color_class_parent_unset");
2075     private static  void color_class_parent_unset(System.IntPtr obj, System.IntPtr pd)
2076    {
2077       Eina.Log.Debug("function efl_canvas_layout_color_class_parent_unset was called");
2078       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2079       if(wrapper != null) {
2080
2081          try {
2082             ((Layout)wrapper).UnsetColorClassParent();
2083          } catch (Exception e) {
2084             Eina.Log.Warning($"Callback error: {e.ToString()}");
2085             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2086          }
2087             } else {
2088          efl_canvas_layout_color_class_parent_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2089       }
2090    }
2091    private static efl_canvas_layout_color_class_parent_unset_delegate efl_canvas_layout_color_class_parent_unset_static_delegate;
2092
2093
2094     private delegate  void efl_canvas_layout_part_text_cursor_coord_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   Edje.Cursor cur,   out  int x,   out  int y);
2095
2096
2097     public delegate  void efl_canvas_layout_part_text_cursor_coord_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   Edje.Cursor cur,   out  int x,   out  int y);
2098     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_coord_get_api_delegate> efl_canvas_layout_part_text_cursor_coord_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_coord_get_api_delegate>(_Module, "efl_canvas_layout_part_text_cursor_coord_get");
2099     private static  void part_text_cursor_coord_get(System.IntPtr obj, System.IntPtr pd,   System.String part,  Edje.Cursor cur,  out  int x,  out  int y)
2100    {
2101       Eina.Log.Debug("function efl_canvas_layout_part_text_cursor_coord_get was called");
2102       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2103       if(wrapper != null) {
2104                                                    x = default( int);      y = default( int);
2105          try {
2106             ((Layout)wrapper).GetPartTextCursorCoord( part,  cur,  out x,  out y);
2107          } catch (Exception e) {
2108             Eina.Log.Warning($"Callback error: {e.ToString()}");
2109             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2110          }
2111                                                             } else {
2112          efl_canvas_layout_part_text_cursor_coord_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  cur,  out x,  out y);
2113       }
2114    }
2115    private static efl_canvas_layout_part_text_cursor_coord_get_delegate efl_canvas_layout_part_text_cursor_coord_get_static_delegate;
2116
2117
2118     private delegate  void efl_canvas_layout_part_text_cursor_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   Edje.Cursor cur,   out  int w,   out  int h);
2119
2120
2121     public delegate  void efl_canvas_layout_part_text_cursor_size_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   Edje.Cursor cur,   out  int w,   out  int h);
2122     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_size_get_api_delegate> efl_canvas_layout_part_text_cursor_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_size_get_api_delegate>(_Module, "efl_canvas_layout_part_text_cursor_size_get");
2123     private static  void part_text_cursor_size_get(System.IntPtr obj, System.IntPtr pd,   System.String part,  Edje.Cursor cur,  out  int w,  out  int h)
2124    {
2125       Eina.Log.Debug("function efl_canvas_layout_part_text_cursor_size_get was called");
2126       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2127       if(wrapper != null) {
2128                                                    w = default( int);      h = default( int);
2129          try {
2130             ((Layout)wrapper).GetPartTextCursorSize( part,  cur,  out w,  out h);
2131          } catch (Exception e) {
2132             Eina.Log.Warning($"Callback error: {e.ToString()}");
2133             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2134          }
2135                                                             } else {
2136          efl_canvas_layout_part_text_cursor_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  cur,  out w,  out h);
2137       }
2138    }
2139    private static efl_canvas_layout_part_text_cursor_size_get_delegate efl_canvas_layout_part_text_cursor_size_get_static_delegate;
2140
2141
2142     private delegate  void efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   out  int x,   out  int y,   out  int w,   out  int h);
2143
2144
2145     public delegate  void efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part,   out  int x,   out  int y,   out  int w,   out  int h);
2146     public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_api_delegate> efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_api_delegate>(_Module, "efl_canvas_layout_part_text_cursor_on_mouse_geometry_get");
2147     private static  void part_text_cursor_on_mouse_geometry_get(System.IntPtr obj, System.IntPtr pd,   System.String part,  out  int x,  out  int y,  out  int w,  out  int h)
2148    {
2149       Eina.Log.Debug("function efl_canvas_layout_part_text_cursor_on_mouse_geometry_get was called");
2150       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2151       if(wrapper != null) {
2152                                                    x = default( int);      y = default( int);      w = default( int);      h = default( int);
2153          try {
2154             ((Layout)wrapper).GetPartTextCursorOnMouseGeometry( part,  out x,  out y,  out w,  out h);
2155          } catch (Exception e) {
2156             Eina.Log.Warning($"Callback error: {e.ToString()}");
2157             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2158          }
2159                                                                         } else {
2160          efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part,  out x,  out y,  out w,  out h);
2161       }
2162    }
2163    private static efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_delegate efl_canvas_layout_part_text_cursor_on_mouse_geometry_get_static_delegate;
2164
2165
2166     private delegate  System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
2167
2168
2169     public delegate  System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
2170     public static Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate> efl_content_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate>(_Module, "efl_content_iterate");
2171     private static  System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
2172    {
2173       Eina.Log.Debug("function efl_content_iterate was called");
2174       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2175       if(wrapper != null) {
2176                   Eina.Iterator<Efl.Gfx.Entity> _ret_var = default(Eina.Iterator<Efl.Gfx.Entity>);
2177          try {
2178             _ret_var = ((Layout)wrapper).ContentIterate();
2179          } catch (Exception e) {
2180             Eina.Log.Warning($"Callback error: {e.ToString()}");
2181             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2182          }
2183       _ret_var.Own = false; return _ret_var.Handle;
2184       } else {
2185          return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2186       }
2187    }
2188    private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
2189
2190
2191     private delegate  int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
2192
2193
2194     public delegate  int efl_content_count_api_delegate(System.IntPtr obj);
2195     public static Efl.Eo.FunctionWrapper<efl_content_count_api_delegate> efl_content_count_ptr = new Efl.Eo.FunctionWrapper<efl_content_count_api_delegate>(_Module, "efl_content_count");
2196     private static  int content_count(System.IntPtr obj, System.IntPtr pd)
2197    {
2198       Eina.Log.Debug("function efl_content_count was called");
2199       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2200       if(wrapper != null) {
2201                    int _ret_var = default( int);
2202          try {
2203             _ret_var = ((Layout)wrapper).ContentCount();
2204          } catch (Exception e) {
2205             Eina.Log.Warning($"Callback error: {e.ToString()}");
2206             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2207          }
2208       return _ret_var;
2209       } else {
2210          return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2211       }
2212    }
2213    private static efl_content_count_delegate efl_content_count_static_delegate;
2214
2215
2216     private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
2217
2218
2219     public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
2220     public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(_Module, "efl_file_mmap_get");
2221     private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
2222    {
2223       Eina.Log.Debug("function efl_file_mmap_get was called");
2224       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2225       if(wrapper != null) {
2226                   Eina.File _ret_var = default(Eina.File);
2227          try {
2228             _ret_var = ((Layout)wrapper).GetMmap();
2229          } catch (Exception e) {
2230             Eina.Log.Warning($"Callback error: {e.ToString()}");
2231             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2232          }
2233       return _ret_var;
2234       } else {
2235          return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2236       }
2237    }
2238    private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
2239
2240
2241     private delegate  Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.File f);
2242
2243
2244     public delegate  Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,   Eina.File f);
2245     public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(_Module, "efl_file_mmap_set");
2246     private static  Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd,  Eina.File f)
2247    {
2248       Eina.Log.Debug("function efl_file_mmap_set was called");
2249       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2250       if(wrapper != null) {
2251                                      Eina.Error _ret_var = default( Eina.Error);
2252          try {
2253             _ret_var = ((Layout)wrapper).SetMmap( f);
2254          } catch (Exception e) {
2255             Eina.Log.Warning($"Callback error: {e.ToString()}");
2256             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2257          }
2258                   return _ret_var;
2259       } else {
2260          return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  f);
2261       }
2262    }
2263    private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
2264
2265
2266     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
2267
2268
2269     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_file_get_api_delegate(System.IntPtr obj);
2270     public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(_Module, "efl_file_get");
2271     private static  System.String file_get(System.IntPtr obj, System.IntPtr pd)
2272    {
2273       Eina.Log.Debug("function efl_file_get was called");
2274       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2275       if(wrapper != null) {
2276                    System.String _ret_var = default( System.String);
2277          try {
2278             _ret_var = ((Layout)wrapper).GetFile();
2279          } catch (Exception e) {
2280             Eina.Log.Warning($"Callback error: {e.ToString()}");
2281             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2282          }
2283       return _ret_var;
2284       } else {
2285          return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2286       }
2287    }
2288    private static efl_file_get_delegate efl_file_get_static_delegate;
2289
2290
2291     private delegate  Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String file);
2292
2293
2294     public delegate  Eina.Error efl_file_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String file);
2295     public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(_Module, "efl_file_set");
2296     private static  Eina.Error file_set(System.IntPtr obj, System.IntPtr pd,   System.String file)
2297    {
2298       Eina.Log.Debug("function efl_file_set was called");
2299       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2300       if(wrapper != null) {
2301                                      Eina.Error _ret_var = default( Eina.Error);
2302          try {
2303             _ret_var = ((Layout)wrapper).SetFile( file);
2304          } catch (Exception e) {
2305             Eina.Log.Warning($"Callback error: {e.ToString()}");
2306             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2307          }
2308                   return _ret_var;
2309       } else {
2310          return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  file);
2311       }
2312    }
2313    private static efl_file_set_delegate efl_file_set_static_delegate;
2314
2315
2316     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
2317
2318
2319     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_file_key_get_api_delegate(System.IntPtr obj);
2320     public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(_Module, "efl_file_key_get");
2321     private static  System.String key_get(System.IntPtr obj, System.IntPtr pd)
2322    {
2323       Eina.Log.Debug("function efl_file_key_get was called");
2324       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2325       if(wrapper != null) {
2326                    System.String _ret_var = default( System.String);
2327          try {
2328             _ret_var = ((Layout)wrapper).GetKey();
2329          } catch (Exception e) {
2330             Eina.Log.Warning($"Callback error: {e.ToString()}");
2331             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2332          }
2333       return _ret_var;
2334       } else {
2335          return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2336       }
2337    }
2338    private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
2339
2340
2341     private delegate  void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key);
2342
2343
2344     public delegate  void efl_file_key_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key);
2345     public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(_Module, "efl_file_key_set");
2346     private static  void key_set(System.IntPtr obj, System.IntPtr pd,   System.String key)
2347    {
2348       Eina.Log.Debug("function efl_file_key_set was called");
2349       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2350       if(wrapper != null) {
2351
2352          try {
2353             ((Layout)wrapper).SetKey( key);
2354          } catch (Exception e) {
2355             Eina.Log.Warning($"Callback error: {e.ToString()}");
2356             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2357          }
2358                         } else {
2359          efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key);
2360       }
2361    }
2362    private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
2363
2364
2365     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
2366
2367
2368     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
2369     public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(_Module, "efl_file_loaded_get");
2370     private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
2371    {
2372       Eina.Log.Debug("function efl_file_loaded_get was called");
2373       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2374       if(wrapper != null) {
2375                   bool _ret_var = default(bool);
2376          try {
2377             _ret_var = ((Layout)wrapper).GetLoaded();
2378          } catch (Exception e) {
2379             Eina.Log.Warning($"Callback error: {e.ToString()}");
2380             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2381          }
2382       return _ret_var;
2383       } else {
2384          return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2385       }
2386    }
2387    private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
2388
2389
2390     private delegate  Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
2391
2392
2393     public delegate  Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
2394     public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(_Module, "efl_file_load");
2395     private static  Eina.Error load(System.IntPtr obj, System.IntPtr pd)
2396    {
2397       Eina.Log.Debug("function efl_file_load was called");
2398       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2399       if(wrapper != null) {
2400                    Eina.Error _ret_var = default( Eina.Error);
2401          try {
2402             _ret_var = ((Layout)wrapper).Load();
2403          } catch (Exception e) {
2404             Eina.Log.Warning($"Callback error: {e.ToString()}");
2405             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2406          }
2407       return _ret_var;
2408       } else {
2409          return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2410       }
2411    }
2412    private static efl_file_load_delegate efl_file_load_static_delegate;
2413
2414
2415     private delegate  void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
2416
2417
2418     public delegate  void efl_file_unload_api_delegate(System.IntPtr obj);
2419     public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(_Module, "efl_file_unload");
2420     private static  void unload(System.IntPtr obj, System.IntPtr pd)
2421    {
2422       Eina.Log.Debug("function efl_file_unload was called");
2423       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2424       if(wrapper != null) {
2425
2426          try {
2427             ((Layout)wrapper).Unload();
2428          } catch (Exception e) {
2429             Eina.Log.Warning($"Callback error: {e.ToString()}");
2430             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2431          }
2432             } else {
2433          efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2434       }
2435    }
2436    private static efl_file_unload_delegate efl_file_unload_static_delegate;
2437
2438
2439     private delegate  void efl_observer_update_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object obs,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key,    System.IntPtr data);
2440
2441
2442     public delegate  void efl_observer_update_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object obs,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key,    System.IntPtr data);
2443     public static Efl.Eo.FunctionWrapper<efl_observer_update_api_delegate> efl_observer_update_ptr = new Efl.Eo.FunctionWrapper<efl_observer_update_api_delegate>(_Module, "efl_observer_update");
2444     private static  void update(System.IntPtr obj, System.IntPtr pd,  Efl.Object obs,   System.String key,   System.IntPtr data)
2445    {
2446       Eina.Log.Debug("function efl_observer_update was called");
2447       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2448       if(wrapper != null) {
2449
2450          try {
2451             ((Layout)wrapper).Update( obs,  key,  data);
2452          } catch (Exception e) {
2453             Eina.Log.Warning($"Callback error: {e.ToString()}");
2454             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2455          }
2456                                                 } else {
2457          efl_observer_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  obs,  key,  data);
2458       }
2459    }
2460    private static efl_observer_update_delegate efl_observer_update_static_delegate;
2461
2462
2463    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_part_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String name);
2464
2465
2466    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_part_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String name);
2467     public static Efl.Eo.FunctionWrapper<efl_part_get_api_delegate> efl_part_get_ptr = new Efl.Eo.FunctionWrapper<efl_part_get_api_delegate>(_Module, "efl_part_get");
2468     private static Efl.Object part_get(System.IntPtr obj, System.IntPtr pd,   System.String name)
2469    {
2470       Eina.Log.Debug("function efl_part_get was called");
2471       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2472       if(wrapper != null) {
2473                                     Efl.Object _ret_var = default(Efl.Object);
2474          try {
2475             _ret_var = ((Layout)wrapper).GetPart( name);
2476          } catch (Exception e) {
2477             Eina.Log.Warning($"Callback error: {e.ToString()}");
2478             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2479          }
2480                   return _ret_var;
2481       } else {
2482          return efl_part_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name);
2483       }
2484    }
2485    private static efl_part_get_delegate efl_part_get_static_delegate;
2486
2487
2488     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_player_playable_get_delegate(System.IntPtr obj, System.IntPtr pd);
2489
2490
2491     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_player_playable_get_api_delegate(System.IntPtr obj);
2492     public static Efl.Eo.FunctionWrapper<efl_player_playable_get_api_delegate> efl_player_playable_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_playable_get_api_delegate>(_Module, "efl_player_playable_get");
2493     private static bool playable_get(System.IntPtr obj, System.IntPtr pd)
2494    {
2495       Eina.Log.Debug("function efl_player_playable_get was called");
2496       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2497       if(wrapper != null) {
2498                   bool _ret_var = default(bool);
2499          try {
2500             _ret_var = ((Layout)wrapper).GetPlayable();
2501          } catch (Exception e) {
2502             Eina.Log.Warning($"Callback error: {e.ToString()}");
2503             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2504          }
2505       return _ret_var;
2506       } else {
2507          return efl_player_playable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2508       }
2509    }
2510    private static efl_player_playable_get_delegate efl_player_playable_get_static_delegate;
2511
2512
2513     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_player_play_get_delegate(System.IntPtr obj, System.IntPtr pd);
2514
2515
2516     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_player_play_get_api_delegate(System.IntPtr obj);
2517     public static Efl.Eo.FunctionWrapper<efl_player_play_get_api_delegate> efl_player_play_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_get_api_delegate>(_Module, "efl_player_play_get");
2518     private static bool play_get(System.IntPtr obj, System.IntPtr pd)
2519    {
2520       Eina.Log.Debug("function efl_player_play_get was called");
2521       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2522       if(wrapper != null) {
2523                   bool _ret_var = default(bool);
2524          try {
2525             _ret_var = ((Layout)wrapper).GetPlay();
2526          } catch (Exception e) {
2527             Eina.Log.Warning($"Callback error: {e.ToString()}");
2528             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2529          }
2530       return _ret_var;
2531       } else {
2532          return efl_player_play_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2533       }
2534    }
2535    private static efl_player_play_get_delegate efl_player_play_get_static_delegate;
2536
2537
2538     private delegate  void efl_player_play_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool play);
2539
2540
2541     public delegate  void efl_player_play_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool play);
2542     public static Efl.Eo.FunctionWrapper<efl_player_play_set_api_delegate> efl_player_play_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_set_api_delegate>(_Module, "efl_player_play_set");
2543     private static  void play_set(System.IntPtr obj, System.IntPtr pd,  bool play)
2544    {
2545       Eina.Log.Debug("function efl_player_play_set was called");
2546       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2547       if(wrapper != null) {
2548
2549          try {
2550             ((Layout)wrapper).SetPlay( play);
2551          } catch (Exception e) {
2552             Eina.Log.Warning($"Callback error: {e.ToString()}");
2553             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2554          }
2555                         } else {
2556          efl_player_play_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  play);
2557       }
2558    }
2559    private static efl_player_play_set_delegate efl_player_play_set_static_delegate;
2560
2561
2562     private delegate double efl_player_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
2563
2564
2565     public delegate double efl_player_pos_get_api_delegate(System.IntPtr obj);
2566     public static Efl.Eo.FunctionWrapper<efl_player_pos_get_api_delegate> efl_player_pos_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_pos_get_api_delegate>(_Module, "efl_player_pos_get");
2567     private static double pos_get(System.IntPtr obj, System.IntPtr pd)
2568    {
2569       Eina.Log.Debug("function efl_player_pos_get was called");
2570       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2571       if(wrapper != null) {
2572                   double _ret_var = default(double);
2573          try {
2574             _ret_var = ((Layout)wrapper).GetPos();
2575          } catch (Exception e) {
2576             Eina.Log.Warning($"Callback error: {e.ToString()}");
2577             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2578          }
2579       return _ret_var;
2580       } else {
2581          return efl_player_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2582       }
2583    }
2584    private static efl_player_pos_get_delegate efl_player_pos_get_static_delegate;
2585
2586
2587     private delegate  void efl_player_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,   double sec);
2588
2589
2590     public delegate  void efl_player_pos_set_api_delegate(System.IntPtr obj,   double sec);
2591     public static Efl.Eo.FunctionWrapper<efl_player_pos_set_api_delegate> efl_player_pos_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_pos_set_api_delegate>(_Module, "efl_player_pos_set");
2592     private static  void pos_set(System.IntPtr obj, System.IntPtr pd,  double sec)
2593    {
2594       Eina.Log.Debug("function efl_player_pos_set was called");
2595       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2596       if(wrapper != null) {
2597
2598          try {
2599             ((Layout)wrapper).SetPos( sec);
2600          } catch (Exception e) {
2601             Eina.Log.Warning($"Callback error: {e.ToString()}");
2602             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2603          }
2604                         } else {
2605          efl_player_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sec);
2606       }
2607    }
2608    private static efl_player_pos_set_delegate efl_player_pos_set_static_delegate;
2609
2610
2611     private delegate double efl_player_progress_get_delegate(System.IntPtr obj, System.IntPtr pd);
2612
2613
2614     public delegate double efl_player_progress_get_api_delegate(System.IntPtr obj);
2615     public static Efl.Eo.FunctionWrapper<efl_player_progress_get_api_delegate> efl_player_progress_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_progress_get_api_delegate>(_Module, "efl_player_progress_get");
2616     private static double progress_get(System.IntPtr obj, System.IntPtr pd)
2617    {
2618       Eina.Log.Debug("function efl_player_progress_get was called");
2619       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2620       if(wrapper != null) {
2621                   double _ret_var = default(double);
2622          try {
2623             _ret_var = ((Layout)wrapper).GetProgress();
2624          } catch (Exception e) {
2625             Eina.Log.Warning($"Callback error: {e.ToString()}");
2626             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2627          }
2628       return _ret_var;
2629       } else {
2630          return efl_player_progress_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2631       }
2632    }
2633    private static efl_player_progress_get_delegate efl_player_progress_get_static_delegate;
2634
2635
2636     private delegate double efl_player_play_speed_get_delegate(System.IntPtr obj, System.IntPtr pd);
2637
2638
2639     public delegate double efl_player_play_speed_get_api_delegate(System.IntPtr obj);
2640     public static Efl.Eo.FunctionWrapper<efl_player_play_speed_get_api_delegate> efl_player_play_speed_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_speed_get_api_delegate>(_Module, "efl_player_play_speed_get");
2641     private static double play_speed_get(System.IntPtr obj, System.IntPtr pd)
2642    {
2643       Eina.Log.Debug("function efl_player_play_speed_get was called");
2644       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2645       if(wrapper != null) {
2646                   double _ret_var = default(double);
2647          try {
2648             _ret_var = ((Layout)wrapper).GetPlaySpeed();
2649          } catch (Exception e) {
2650             Eina.Log.Warning($"Callback error: {e.ToString()}");
2651             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2652          }
2653       return _ret_var;
2654       } else {
2655          return efl_player_play_speed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2656       }
2657    }
2658    private static efl_player_play_speed_get_delegate efl_player_play_speed_get_static_delegate;
2659
2660
2661     private delegate  void efl_player_play_speed_set_delegate(System.IntPtr obj, System.IntPtr pd,   double speed);
2662
2663
2664     public delegate  void efl_player_play_speed_set_api_delegate(System.IntPtr obj,   double speed);
2665     public static Efl.Eo.FunctionWrapper<efl_player_play_speed_set_api_delegate> efl_player_play_speed_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_speed_set_api_delegate>(_Module, "efl_player_play_speed_set");
2666     private static  void play_speed_set(System.IntPtr obj, System.IntPtr pd,  double speed)
2667    {
2668       Eina.Log.Debug("function efl_player_play_speed_set was called");
2669       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2670       if(wrapper != null) {
2671
2672          try {
2673             ((Layout)wrapper).SetPlaySpeed( speed);
2674          } catch (Exception e) {
2675             Eina.Log.Warning($"Callback error: {e.ToString()}");
2676             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2677          }
2678                         } else {
2679          efl_player_play_speed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  speed);
2680       }
2681    }
2682    private static efl_player_play_speed_set_delegate efl_player_play_speed_set_static_delegate;
2683
2684
2685     private delegate double efl_player_volume_get_delegate(System.IntPtr obj, System.IntPtr pd);
2686
2687
2688     public delegate double efl_player_volume_get_api_delegate(System.IntPtr obj);
2689     public static Efl.Eo.FunctionWrapper<efl_player_volume_get_api_delegate> efl_player_volume_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_volume_get_api_delegate>(_Module, "efl_player_volume_get");
2690     private static double volume_get(System.IntPtr obj, System.IntPtr pd)
2691    {
2692       Eina.Log.Debug("function efl_player_volume_get was called");
2693       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2694       if(wrapper != null) {
2695                   double _ret_var = default(double);
2696          try {
2697             _ret_var = ((Layout)wrapper).GetVolume();
2698          } catch (Exception e) {
2699             Eina.Log.Warning($"Callback error: {e.ToString()}");
2700             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2701          }
2702       return _ret_var;
2703       } else {
2704          return efl_player_volume_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2705       }
2706    }
2707    private static efl_player_volume_get_delegate efl_player_volume_get_static_delegate;
2708
2709
2710     private delegate  void efl_player_volume_set_delegate(System.IntPtr obj, System.IntPtr pd,   double volume);
2711
2712
2713     public delegate  void efl_player_volume_set_api_delegate(System.IntPtr obj,   double volume);
2714     public static Efl.Eo.FunctionWrapper<efl_player_volume_set_api_delegate> efl_player_volume_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_volume_set_api_delegate>(_Module, "efl_player_volume_set");
2715     private static  void volume_set(System.IntPtr obj, System.IntPtr pd,  double volume)
2716    {
2717       Eina.Log.Debug("function efl_player_volume_set was called");
2718       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2719       if(wrapper != null) {
2720
2721          try {
2722             ((Layout)wrapper).SetVolume( volume);
2723          } catch (Exception e) {
2724             Eina.Log.Warning($"Callback error: {e.ToString()}");
2725             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2726          }
2727                         } else {
2728          efl_player_volume_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  volume);
2729       }
2730    }
2731    private static efl_player_volume_set_delegate efl_player_volume_set_static_delegate;
2732
2733
2734     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_player_mute_get_delegate(System.IntPtr obj, System.IntPtr pd);
2735
2736
2737     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_player_mute_get_api_delegate(System.IntPtr obj);
2738     public static Efl.Eo.FunctionWrapper<efl_player_mute_get_api_delegate> efl_player_mute_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_mute_get_api_delegate>(_Module, "efl_player_mute_get");
2739     private static bool mute_get(System.IntPtr obj, System.IntPtr pd)
2740    {
2741       Eina.Log.Debug("function efl_player_mute_get was called");
2742       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2743       if(wrapper != null) {
2744                   bool _ret_var = default(bool);
2745          try {
2746             _ret_var = ((Layout)wrapper).GetMute();
2747          } catch (Exception e) {
2748             Eina.Log.Warning($"Callback error: {e.ToString()}");
2749             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2750          }
2751       return _ret_var;
2752       } else {
2753          return efl_player_mute_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2754       }
2755    }
2756    private static efl_player_mute_get_delegate efl_player_mute_get_static_delegate;
2757
2758
2759     private delegate  void efl_player_mute_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool mute);
2760
2761
2762     public delegate  void efl_player_mute_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool mute);
2763     public static Efl.Eo.FunctionWrapper<efl_player_mute_set_api_delegate> efl_player_mute_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_mute_set_api_delegate>(_Module, "efl_player_mute_set");
2764     private static  void mute_set(System.IntPtr obj, System.IntPtr pd,  bool mute)
2765    {
2766       Eina.Log.Debug("function efl_player_mute_set was called");
2767       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2768       if(wrapper != null) {
2769
2770          try {
2771             ((Layout)wrapper).SetMute( mute);
2772          } catch (Exception e) {
2773             Eina.Log.Warning($"Callback error: {e.ToString()}");
2774             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2775          }
2776                         } else {
2777          efl_player_mute_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mute);
2778       }
2779    }
2780    private static efl_player_mute_set_delegate efl_player_mute_set_static_delegate;
2781
2782
2783     private delegate double efl_player_length_get_delegate(System.IntPtr obj, System.IntPtr pd);
2784
2785
2786     public delegate double efl_player_length_get_api_delegate(System.IntPtr obj);
2787     public static Efl.Eo.FunctionWrapper<efl_player_length_get_api_delegate> efl_player_length_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_length_get_api_delegate>(_Module, "efl_player_length_get");
2788     private static double length_get(System.IntPtr obj, System.IntPtr pd)
2789    {
2790       Eina.Log.Debug("function efl_player_length_get was called");
2791       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2792       if(wrapper != null) {
2793                   double _ret_var = default(double);
2794          try {
2795             _ret_var = ((Layout)wrapper).GetLength();
2796          } catch (Exception e) {
2797             Eina.Log.Warning($"Callback error: {e.ToString()}");
2798             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2799          }
2800       return _ret_var;
2801       } else {
2802          return efl_player_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2803       }
2804    }
2805    private static efl_player_length_get_delegate efl_player_length_get_static_delegate;
2806
2807
2808     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_player_seekable_get_delegate(System.IntPtr obj, System.IntPtr pd);
2809
2810
2811     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_player_seekable_get_api_delegate(System.IntPtr obj);
2812     public static Efl.Eo.FunctionWrapper<efl_player_seekable_get_api_delegate> efl_player_seekable_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_seekable_get_api_delegate>(_Module, "efl_player_seekable_get");
2813     private static bool seekable_get(System.IntPtr obj, System.IntPtr pd)
2814    {
2815       Eina.Log.Debug("function efl_player_seekable_get was called");
2816       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2817       if(wrapper != null) {
2818                   bool _ret_var = default(bool);
2819          try {
2820             _ret_var = ((Layout)wrapper).GetSeekable();
2821          } catch (Exception e) {
2822             Eina.Log.Warning($"Callback error: {e.ToString()}");
2823             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2824          }
2825       return _ret_var;
2826       } else {
2827          return efl_player_seekable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2828       }
2829    }
2830    private static efl_player_seekable_get_delegate efl_player_seekable_get_static_delegate;
2831
2832
2833     private delegate  void efl_player_start_delegate(System.IntPtr obj, System.IntPtr pd);
2834
2835
2836     public delegate  void efl_player_start_api_delegate(System.IntPtr obj);
2837     public static Efl.Eo.FunctionWrapper<efl_player_start_api_delegate> efl_player_start_ptr = new Efl.Eo.FunctionWrapper<efl_player_start_api_delegate>(_Module, "efl_player_start");
2838     private static  void start(System.IntPtr obj, System.IntPtr pd)
2839    {
2840       Eina.Log.Debug("function efl_player_start was called");
2841       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2842       if(wrapper != null) {
2843
2844          try {
2845             ((Layout)wrapper).Start();
2846          } catch (Exception e) {
2847             Eina.Log.Warning($"Callback error: {e.ToString()}");
2848             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2849          }
2850             } else {
2851          efl_player_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2852       }
2853    }
2854    private static efl_player_start_delegate efl_player_start_static_delegate;
2855
2856
2857     private delegate  void efl_player_stop_delegate(System.IntPtr obj, System.IntPtr pd);
2858
2859
2860     public delegate  void efl_player_stop_api_delegate(System.IntPtr obj);
2861     public static Efl.Eo.FunctionWrapper<efl_player_stop_api_delegate> efl_player_stop_ptr = new Efl.Eo.FunctionWrapper<efl_player_stop_api_delegate>(_Module, "efl_player_stop");
2862     private static  void stop(System.IntPtr obj, System.IntPtr pd)
2863    {
2864       Eina.Log.Debug("function efl_player_stop was called");
2865       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2866       if(wrapper != null) {
2867
2868          try {
2869             ((Layout)wrapper).Stop();
2870          } catch (Exception e) {
2871             Eina.Log.Warning($"Callback error: {e.ToString()}");
2872             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2873          }
2874             } else {
2875          efl_player_stop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2876       }
2877    }
2878    private static efl_player_stop_delegate efl_player_stop_static_delegate;
2879
2880
2881     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_color_class_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,   out  int r,   out  int g,   out  int b,   out  int a);
2882
2883
2884     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_color_class_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,   out  int r,   out  int g,   out  int b,   out  int a);
2885     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_get_api_delegate> efl_gfx_color_class_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_get_api_delegate>(_Module, "efl_gfx_color_class_get");
2886     private static bool color_class_get(System.IntPtr obj, System.IntPtr pd,   System.String color_class,  Efl.Gfx.ColorClassLayer layer,  out  int r,  out  int g,  out  int b,  out  int a)
2887    {
2888       Eina.Log.Debug("function efl_gfx_color_class_get was called");
2889       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2890       if(wrapper != null) {
2891                                                                r = default( int);      g = default( int);      b = default( int);      a = default( int);                                             bool _ret_var = default(bool);
2892          try {
2893             _ret_var = ((Layout)wrapper).GetColorClass( color_class,  layer,  out r,  out g,  out b,  out a);
2894          } catch (Exception e) {
2895             Eina.Log.Warning($"Callback error: {e.ToString()}");
2896             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2897          }
2898                                                                               return _ret_var;
2899       } else {
2900          return efl_gfx_color_class_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class,  layer,  out r,  out g,  out b,  out a);
2901       }
2902    }
2903    private static efl_gfx_color_class_get_delegate efl_gfx_color_class_get_static_delegate;
2904
2905
2906     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_color_class_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,    int r,    int g,    int b,    int a);
2907
2908
2909     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_color_class_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,    int r,    int g,    int b,    int a);
2910     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_set_api_delegate> efl_gfx_color_class_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_set_api_delegate>(_Module, "efl_gfx_color_class_set");
2911     private static bool color_class_set(System.IntPtr obj, System.IntPtr pd,   System.String color_class,  Efl.Gfx.ColorClassLayer layer,   int r,   int g,   int b,   int a)
2912    {
2913       Eina.Log.Debug("function efl_gfx_color_class_set was called");
2914       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2915       if(wrapper != null) {
2916                                                                                                                               bool _ret_var = default(bool);
2917          try {
2918             _ret_var = ((Layout)wrapper).SetColorClass( color_class,  layer,  r,  g,  b,  a);
2919          } catch (Exception e) {
2920             Eina.Log.Warning($"Callback error: {e.ToString()}");
2921             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2922          }
2923                                                                               return _ret_var;
2924       } else {
2925          return efl_gfx_color_class_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class,  layer,  r,  g,  b,  a);
2926       }
2927    }
2928    private static efl_gfx_color_class_set_delegate efl_gfx_color_class_set_static_delegate;
2929
2930
2931     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_gfx_color_class_code_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer);
2932
2933
2934     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_gfx_color_class_code_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer);
2935     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_code_get_api_delegate> efl_gfx_color_class_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_code_get_api_delegate>(_Module, "efl_gfx_color_class_code_get");
2936     private static  System.String color_class_code_get(System.IntPtr obj, System.IntPtr pd,   System.String color_class,  Efl.Gfx.ColorClassLayer layer)
2937    {
2938       Eina.Log.Debug("function efl_gfx_color_class_code_get was called");
2939       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2940       if(wrapper != null) {
2941                                                        System.String _ret_var = default( System.String);
2942          try {
2943             _ret_var = ((Layout)wrapper).GetColorClassCode( color_class,  layer);
2944          } catch (Exception e) {
2945             Eina.Log.Warning($"Callback error: {e.ToString()}");
2946             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2947          }
2948                               return _ret_var;
2949       } else {
2950          return efl_gfx_color_class_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class,  layer);
2951       }
2952    }
2953    private static efl_gfx_color_class_code_get_delegate efl_gfx_color_class_code_get_static_delegate;
2954
2955
2956     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_color_class_code_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String colorcode);
2957
2958
2959     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_color_class_code_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class,   Efl.Gfx.ColorClassLayer layer,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String colorcode);
2960     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_code_set_api_delegate> efl_gfx_color_class_code_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_code_set_api_delegate>(_Module, "efl_gfx_color_class_code_set");
2961     private static bool color_class_code_set(System.IntPtr obj, System.IntPtr pd,   System.String color_class,  Efl.Gfx.ColorClassLayer layer,   System.String colorcode)
2962    {
2963       Eina.Log.Debug("function efl_gfx_color_class_code_set was called");
2964       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2965       if(wrapper != null) {
2966                                                                         bool _ret_var = default(bool);
2967          try {
2968             _ret_var = ((Layout)wrapper).SetColorClassCode( color_class,  layer,  colorcode);
2969          } catch (Exception e) {
2970             Eina.Log.Warning($"Callback error: {e.ToString()}");
2971             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2972          }
2973                                           return _ret_var;
2974       } else {
2975          return efl_gfx_color_class_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class,  layer,  colorcode);
2976       }
2977    }
2978    private static efl_gfx_color_class_code_set_delegate efl_gfx_color_class_code_set_static_delegate;
2979
2980
2981     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_gfx_color_class_description_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class);
2982
2983
2984     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_gfx_color_class_description_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class);
2985     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_description_get_api_delegate> efl_gfx_color_class_description_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_description_get_api_delegate>(_Module, "efl_gfx_color_class_description_get");
2986     private static  System.String color_class_description_get(System.IntPtr obj, System.IntPtr pd,   System.String color_class)
2987    {
2988       Eina.Log.Debug("function efl_gfx_color_class_description_get was called");
2989       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2990       if(wrapper != null) {
2991                                      System.String _ret_var = default( System.String);
2992          try {
2993             _ret_var = ((Layout)wrapper).GetColorClassDescription( color_class);
2994          } catch (Exception e) {
2995             Eina.Log.Warning($"Callback error: {e.ToString()}");
2996             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2997          }
2998                   return _ret_var;
2999       } else {
3000          return efl_gfx_color_class_description_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class);
3001       }
3002    }
3003    private static efl_gfx_color_class_description_get_delegate efl_gfx_color_class_description_get_static_delegate;
3004
3005
3006     private delegate  void efl_gfx_color_class_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class);
3007
3008
3009     public delegate  void efl_gfx_color_class_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String color_class);
3010     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_del_api_delegate> efl_gfx_color_class_del_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_del_api_delegate>(_Module, "efl_gfx_color_class_del");
3011     private static  void color_class_del(System.IntPtr obj, System.IntPtr pd,   System.String color_class)
3012    {
3013       Eina.Log.Debug("function efl_gfx_color_class_del was called");
3014       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3015       if(wrapper != null) {
3016
3017          try {
3018             ((Layout)wrapper).DelColorClass( color_class);
3019          } catch (Exception e) {
3020             Eina.Log.Warning($"Callback error: {e.ToString()}");
3021             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3022          }
3023                         } else {
3024          efl_gfx_color_class_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  color_class);
3025       }
3026    }
3027    private static efl_gfx_color_class_del_delegate efl_gfx_color_class_del_static_delegate;
3028
3029
3030     private delegate  void efl_gfx_color_class_clear_delegate(System.IntPtr obj, System.IntPtr pd);
3031
3032
3033     public delegate  void efl_gfx_color_class_clear_api_delegate(System.IntPtr obj);
3034     public static Efl.Eo.FunctionWrapper<efl_gfx_color_class_clear_api_delegate> efl_gfx_color_class_clear_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_class_clear_api_delegate>(_Module, "efl_gfx_color_class_clear");
3035     private static  void color_class_clear(System.IntPtr obj, System.IntPtr pd)
3036    {
3037       Eina.Log.Debug("function efl_gfx_color_class_clear was called");
3038       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3039       if(wrapper != null) {
3040
3041          try {
3042             ((Layout)wrapper).ClearColorClass();
3043          } catch (Exception e) {
3044             Eina.Log.Warning($"Callback error: {e.ToString()}");
3045             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3046          }
3047             } else {
3048          efl_gfx_color_class_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3049       }
3050    }
3051    private static efl_gfx_color_class_clear_delegate efl_gfx_color_class_clear_static_delegate;
3052
3053
3054     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_size_class_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class,   out  int minw,   out  int minh,   out  int maxw,   out  int maxh);
3055
3056
3057     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_size_class_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class,   out  int minw,   out  int minh,   out  int maxw,   out  int maxh);
3058     public static Efl.Eo.FunctionWrapper<efl_gfx_size_class_get_api_delegate> efl_gfx_size_class_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_size_class_get_api_delegate>(_Module, "efl_gfx_size_class_get");
3059     private static bool size_class_get(System.IntPtr obj, System.IntPtr pd,   System.String size_class,  out  int minw,  out  int minh,  out  int maxw,  out  int maxh)
3060    {
3061       Eina.Log.Debug("function efl_gfx_size_class_get was called");
3062       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3063       if(wrapper != null) {
3064                                                    minw = default( int);      minh = default( int);      maxw = default( int);      maxh = default( int);                                       bool _ret_var = default(bool);
3065          try {
3066             _ret_var = ((Layout)wrapper).GetSizeClass( size_class,  out minw,  out minh,  out maxw,  out maxh);
3067          } catch (Exception e) {
3068             Eina.Log.Warning($"Callback error: {e.ToString()}");
3069             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3070          }
3071                                                                   return _ret_var;
3072       } else {
3073          return efl_gfx_size_class_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size_class,  out minw,  out minh,  out maxw,  out maxh);
3074       }
3075    }
3076    private static efl_gfx_size_class_get_delegate efl_gfx_size_class_get_static_delegate;
3077
3078
3079     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_size_class_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class,    int minw,    int minh,    int maxw,    int maxh);
3080
3081
3082     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_size_class_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class,    int minw,    int minh,    int maxw,    int maxh);
3083     public static Efl.Eo.FunctionWrapper<efl_gfx_size_class_set_api_delegate> efl_gfx_size_class_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_size_class_set_api_delegate>(_Module, "efl_gfx_size_class_set");
3084     private static bool size_class_set(System.IntPtr obj, System.IntPtr pd,   System.String size_class,   int minw,   int minh,   int maxw,   int maxh)
3085    {
3086       Eina.Log.Debug("function efl_gfx_size_class_set was called");
3087       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3088       if(wrapper != null) {
3089                                                                                                             bool _ret_var = default(bool);
3090          try {
3091             _ret_var = ((Layout)wrapper).SetSizeClass( size_class,  minw,  minh,  maxw,  maxh);
3092          } catch (Exception e) {
3093             Eina.Log.Warning($"Callback error: {e.ToString()}");
3094             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3095          }
3096                                                                   return _ret_var;
3097       } else {
3098          return efl_gfx_size_class_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size_class,  minw,  minh,  maxw,  maxh);
3099       }
3100    }
3101    private static efl_gfx_size_class_set_delegate efl_gfx_size_class_set_static_delegate;
3102
3103
3104     private delegate  void efl_gfx_size_class_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class);
3105
3106
3107     public delegate  void efl_gfx_size_class_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String size_class);
3108     public static Efl.Eo.FunctionWrapper<efl_gfx_size_class_del_api_delegate> efl_gfx_size_class_del_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_size_class_del_api_delegate>(_Module, "efl_gfx_size_class_del");
3109     private static  void size_class_del(System.IntPtr obj, System.IntPtr pd,   System.String size_class)
3110    {
3111       Eina.Log.Debug("function efl_gfx_size_class_del was called");
3112       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3113       if(wrapper != null) {
3114
3115          try {
3116             ((Layout)wrapper).DelSizeClass( size_class);
3117          } catch (Exception e) {
3118             Eina.Log.Warning($"Callback error: {e.ToString()}");
3119             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3120          }
3121                         } else {
3122          efl_gfx_size_class_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size_class);
3123       }
3124    }
3125    private static efl_gfx_size_class_del_delegate efl_gfx_size_class_del_static_delegate;
3126
3127
3128     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_text_class_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  out  System.String font,   out Efl.Font.Size size);
3129
3130
3131     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_text_class_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  out  System.String font,   out Efl.Font.Size size);
3132     public static Efl.Eo.FunctionWrapper<efl_gfx_text_class_get_api_delegate> efl_gfx_text_class_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_text_class_get_api_delegate>(_Module, "efl_gfx_text_class_get");
3133     private static bool text_class_get(System.IntPtr obj, System.IntPtr pd,   System.String text_class,  out  System.String font,  out Efl.Font.Size size)
3134    {
3135       Eina.Log.Debug("function efl_gfx_text_class_get was called");
3136       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3137       if(wrapper != null) {
3138                                         System.String _out_font = default( System.String);
3139       size = default(Efl.Font.Size);                           bool _ret_var = default(bool);
3140          try {
3141             _ret_var = ((Layout)wrapper).GetTextClass( text_class,  out _out_font,  out size);
3142          } catch (Exception e) {
3143             Eina.Log.Warning($"Callback error: {e.ToString()}");
3144             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3145          }
3146             font = _out_font;
3147                               return _ret_var;
3148       } else {
3149          return efl_gfx_text_class_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  text_class,  out font,  out size);
3150       }
3151    }
3152    private static efl_gfx_text_class_get_delegate efl_gfx_text_class_get_static_delegate;
3153
3154
3155     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_text_class_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String font,   Efl.Font.Size size);
3156
3157
3158     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_text_class_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String font,   Efl.Font.Size size);
3159     public static Efl.Eo.FunctionWrapper<efl_gfx_text_class_set_api_delegate> efl_gfx_text_class_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_text_class_set_api_delegate>(_Module, "efl_gfx_text_class_set");
3160     private static bool text_class_set(System.IntPtr obj, System.IntPtr pd,   System.String text_class,   System.String font,  Efl.Font.Size size)
3161    {
3162       Eina.Log.Debug("function efl_gfx_text_class_set was called");
3163       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3164       if(wrapper != null) {
3165                                                                         bool _ret_var = default(bool);
3166          try {
3167             _ret_var = ((Layout)wrapper).SetTextClass( text_class,  font,  size);
3168          } catch (Exception e) {
3169             Eina.Log.Warning($"Callback error: {e.ToString()}");
3170             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3171          }
3172                                           return _ret_var;
3173       } else {
3174          return efl_gfx_text_class_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  text_class,  font,  size);
3175       }
3176    }
3177    private static efl_gfx_text_class_set_delegate efl_gfx_text_class_set_static_delegate;
3178
3179
3180     private delegate  void efl_gfx_text_class_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class);
3181
3182
3183     public delegate  void efl_gfx_text_class_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text_class);
3184     public static Efl.Eo.FunctionWrapper<efl_gfx_text_class_del_api_delegate> efl_gfx_text_class_del_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_text_class_del_api_delegate>(_Module, "efl_gfx_text_class_del");
3185     private static  void text_class_del(System.IntPtr obj, System.IntPtr pd,   System.String text_class)
3186    {
3187       Eina.Log.Debug("function efl_gfx_text_class_del was called");
3188       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3189       if(wrapper != null) {
3190
3191          try {
3192             ((Layout)wrapper).DelTextClass( text_class);
3193          } catch (Exception e) {
3194             Eina.Log.Warning($"Callback error: {e.ToString()}");
3195             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3196          }
3197                         } else {
3198          efl_gfx_text_class_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  text_class);
3199       }
3200    }
3201    private static efl_gfx_text_class_del_delegate efl_gfx_text_class_del_static_delegate;
3202
3203
3204     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_calc_auto_update_hints_get_delegate(System.IntPtr obj, System.IntPtr pd);
3205
3206
3207     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_calc_auto_update_hints_get_api_delegate(System.IntPtr obj);
3208     public static Efl.Eo.FunctionWrapper<efl_layout_calc_auto_update_hints_get_api_delegate> efl_layout_calc_auto_update_hints_get_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_auto_update_hints_get_api_delegate>(_Module, "efl_layout_calc_auto_update_hints_get");
3209     private static bool calc_auto_update_hints_get(System.IntPtr obj, System.IntPtr pd)
3210    {
3211       Eina.Log.Debug("function efl_layout_calc_auto_update_hints_get was called");
3212       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3213       if(wrapper != null) {
3214                   bool _ret_var = default(bool);
3215          try {
3216             _ret_var = ((Layout)wrapper).GetCalcAutoUpdateHints();
3217          } catch (Exception e) {
3218             Eina.Log.Warning($"Callback error: {e.ToString()}");
3219             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3220          }
3221       return _ret_var;
3222       } else {
3223          return efl_layout_calc_auto_update_hints_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3224       }
3225    }
3226    private static efl_layout_calc_auto_update_hints_get_delegate efl_layout_calc_auto_update_hints_get_static_delegate;
3227
3228
3229     private delegate  void efl_layout_calc_auto_update_hints_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool update);
3230
3231
3232     public delegate  void efl_layout_calc_auto_update_hints_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool update);
3233     public static Efl.Eo.FunctionWrapper<efl_layout_calc_auto_update_hints_set_api_delegate> efl_layout_calc_auto_update_hints_set_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_auto_update_hints_set_api_delegate>(_Module, "efl_layout_calc_auto_update_hints_set");
3234     private static  void calc_auto_update_hints_set(System.IntPtr obj, System.IntPtr pd,  bool update)
3235    {
3236       Eina.Log.Debug("function efl_layout_calc_auto_update_hints_set was called");
3237       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3238       if(wrapper != null) {
3239
3240          try {
3241             ((Layout)wrapper).SetCalcAutoUpdateHints( update);
3242          } catch (Exception e) {
3243             Eina.Log.Warning($"Callback error: {e.ToString()}");
3244             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3245          }
3246                         } else {
3247          efl_layout_calc_auto_update_hints_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  update);
3248       }
3249    }
3250    private static efl_layout_calc_auto_update_hints_set_delegate efl_layout_calc_auto_update_hints_set_static_delegate;
3251
3252
3253     private delegate Eina.Size2D_StructInternal efl_layout_calc_size_min_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal restricted);
3254
3255
3256     public delegate Eina.Size2D_StructInternal efl_layout_calc_size_min_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal restricted);
3257     public static Efl.Eo.FunctionWrapper<efl_layout_calc_size_min_api_delegate> efl_layout_calc_size_min_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_size_min_api_delegate>(_Module, "efl_layout_calc_size_min");
3258     private static Eina.Size2D_StructInternal calc_size_min(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal restricted)
3259    {
3260       Eina.Log.Debug("function efl_layout_calc_size_min was called");
3261       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3262       if(wrapper != null) {
3263                var _in_restricted = Eina.Size2D_StructConversion.ToManaged(restricted);
3264                      Eina.Size2D _ret_var = default(Eina.Size2D);
3265          try {
3266             _ret_var = ((Layout)wrapper).CalcSizeMin( _in_restricted);
3267          } catch (Exception e) {
3268             Eina.Log.Warning($"Callback error: {e.ToString()}");
3269             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3270          }
3271                   return Eina.Size2D_StructConversion.ToInternal(_ret_var);
3272       } else {
3273          return efl_layout_calc_size_min_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  restricted);
3274       }
3275    }
3276    private static efl_layout_calc_size_min_delegate efl_layout_calc_size_min_static_delegate;
3277
3278
3279     private delegate Eina.Rect_StructInternal efl_layout_calc_parts_extends_delegate(System.IntPtr obj, System.IntPtr pd);
3280
3281
3282     public delegate Eina.Rect_StructInternal efl_layout_calc_parts_extends_api_delegate(System.IntPtr obj);
3283     public static Efl.Eo.FunctionWrapper<efl_layout_calc_parts_extends_api_delegate> efl_layout_calc_parts_extends_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_parts_extends_api_delegate>(_Module, "efl_layout_calc_parts_extends");
3284     private static Eina.Rect_StructInternal calc_parts_extends(System.IntPtr obj, System.IntPtr pd)
3285    {
3286       Eina.Log.Debug("function efl_layout_calc_parts_extends was called");
3287       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3288       if(wrapper != null) {
3289                   Eina.Rect _ret_var = default(Eina.Rect);
3290          try {
3291             _ret_var = ((Layout)wrapper).CalcPartsExtends();
3292          } catch (Exception e) {
3293             Eina.Log.Warning($"Callback error: {e.ToString()}");
3294             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3295          }
3296       return Eina.Rect_StructConversion.ToInternal(_ret_var);
3297       } else {
3298          return efl_layout_calc_parts_extends_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3299       }
3300    }
3301    private static efl_layout_calc_parts_extends_delegate efl_layout_calc_parts_extends_static_delegate;
3302
3303
3304     private delegate  int efl_layout_calc_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
3305
3306
3307     public delegate  int efl_layout_calc_freeze_api_delegate(System.IntPtr obj);
3308     public static Efl.Eo.FunctionWrapper<efl_layout_calc_freeze_api_delegate> efl_layout_calc_freeze_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_freeze_api_delegate>(_Module, "efl_layout_calc_freeze");
3309     private static  int calc_freeze(System.IntPtr obj, System.IntPtr pd)
3310    {
3311       Eina.Log.Debug("function efl_layout_calc_freeze was called");
3312       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3313       if(wrapper != null) {
3314                    int _ret_var = default( int);
3315          try {
3316             _ret_var = ((Layout)wrapper).FreezeCalc();
3317          } catch (Exception e) {
3318             Eina.Log.Warning($"Callback error: {e.ToString()}");
3319             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3320          }
3321       return _ret_var;
3322       } else {
3323          return efl_layout_calc_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3324       }
3325    }
3326    private static efl_layout_calc_freeze_delegate efl_layout_calc_freeze_static_delegate;
3327
3328
3329     private delegate  int efl_layout_calc_thaw_delegate(System.IntPtr obj, System.IntPtr pd);
3330
3331
3332     public delegate  int efl_layout_calc_thaw_api_delegate(System.IntPtr obj);
3333     public static Efl.Eo.FunctionWrapper<efl_layout_calc_thaw_api_delegate> efl_layout_calc_thaw_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_thaw_api_delegate>(_Module, "efl_layout_calc_thaw");
3334     private static  int calc_thaw(System.IntPtr obj, System.IntPtr pd)
3335    {
3336       Eina.Log.Debug("function efl_layout_calc_thaw was called");
3337       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3338       if(wrapper != null) {
3339                    int _ret_var = default( int);
3340          try {
3341             _ret_var = ((Layout)wrapper).ThawCalc();
3342          } catch (Exception e) {
3343             Eina.Log.Warning($"Callback error: {e.ToString()}");
3344             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3345          }
3346       return _ret_var;
3347       } else {
3348          return efl_layout_calc_thaw_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3349       }
3350    }
3351    private static efl_layout_calc_thaw_delegate efl_layout_calc_thaw_static_delegate;
3352
3353
3354     private delegate  void efl_layout_calc_force_delegate(System.IntPtr obj, System.IntPtr pd);
3355
3356
3357     public delegate  void efl_layout_calc_force_api_delegate(System.IntPtr obj);
3358     public static Efl.Eo.FunctionWrapper<efl_layout_calc_force_api_delegate> efl_layout_calc_force_ptr = new Efl.Eo.FunctionWrapper<efl_layout_calc_force_api_delegate>(_Module, "efl_layout_calc_force");
3359     private static  void calc_force(System.IntPtr obj, System.IntPtr pd)
3360    {
3361       Eina.Log.Debug("function efl_layout_calc_force was called");
3362       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3363       if(wrapper != null) {
3364
3365          try {
3366             ((Layout)wrapper).CalcForce();
3367          } catch (Exception e) {
3368             Eina.Log.Warning($"Callback error: {e.ToString()}");
3369             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3370          }
3371             } else {
3372          efl_layout_calc_force_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3373       }
3374    }
3375    private static efl_layout_calc_force_delegate efl_layout_calc_force_static_delegate;
3376
3377
3378     private delegate Eina.Size2D_StructInternal efl_layout_group_size_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
3379
3380
3381     public delegate Eina.Size2D_StructInternal efl_layout_group_size_min_get_api_delegate(System.IntPtr obj);
3382     public static Efl.Eo.FunctionWrapper<efl_layout_group_size_min_get_api_delegate> efl_layout_group_size_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_layout_group_size_min_get_api_delegate>(_Module, "efl_layout_group_size_min_get");
3383     private static Eina.Size2D_StructInternal group_size_min_get(System.IntPtr obj, System.IntPtr pd)
3384    {
3385       Eina.Log.Debug("function efl_layout_group_size_min_get was called");
3386       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3387       if(wrapper != null) {
3388                   Eina.Size2D _ret_var = default(Eina.Size2D);
3389          try {
3390             _ret_var = ((Layout)wrapper).GetGroupSizeMin();
3391          } catch (Exception e) {
3392             Eina.Log.Warning($"Callback error: {e.ToString()}");
3393             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3394          }
3395       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
3396       } else {
3397          return efl_layout_group_size_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3398       }
3399    }
3400    private static efl_layout_group_size_min_get_delegate efl_layout_group_size_min_get_static_delegate;
3401
3402
3403     private delegate Eina.Size2D_StructInternal efl_layout_group_size_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
3404
3405
3406     public delegate Eina.Size2D_StructInternal efl_layout_group_size_max_get_api_delegate(System.IntPtr obj);
3407     public static Efl.Eo.FunctionWrapper<efl_layout_group_size_max_get_api_delegate> efl_layout_group_size_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_layout_group_size_max_get_api_delegate>(_Module, "efl_layout_group_size_max_get");
3408     private static Eina.Size2D_StructInternal group_size_max_get(System.IntPtr obj, System.IntPtr pd)
3409    {
3410       Eina.Log.Debug("function efl_layout_group_size_max_get was called");
3411       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3412       if(wrapper != null) {
3413                   Eina.Size2D _ret_var = default(Eina.Size2D);
3414          try {
3415             _ret_var = ((Layout)wrapper).GetGroupSizeMax();
3416          } catch (Exception e) {
3417             Eina.Log.Warning($"Callback error: {e.ToString()}");
3418             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3419          }
3420       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
3421       } else {
3422          return efl_layout_group_size_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3423       }
3424    }
3425    private static efl_layout_group_size_max_get_delegate efl_layout_group_size_max_get_static_delegate;
3426
3427
3428     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_layout_group_data_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key);
3429
3430
3431     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_layout_group_data_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key);
3432     public static Efl.Eo.FunctionWrapper<efl_layout_group_data_get_api_delegate> efl_layout_group_data_get_ptr = new Efl.Eo.FunctionWrapper<efl_layout_group_data_get_api_delegate>(_Module, "efl_layout_group_data_get");
3433     private static  System.String group_data_get(System.IntPtr obj, System.IntPtr pd,   System.String key)
3434    {
3435       Eina.Log.Debug("function efl_layout_group_data_get was called");
3436       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3437       if(wrapper != null) {
3438                                      System.String _ret_var = default( System.String);
3439          try {
3440             _ret_var = ((Layout)wrapper).GetGroupData( key);
3441          } catch (Exception e) {
3442             Eina.Log.Warning($"Callback error: {e.ToString()}");
3443             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3444          }
3445                   return _ret_var;
3446       } else {
3447          return efl_layout_group_data_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key);
3448       }
3449    }
3450    private static efl_layout_group_data_get_delegate efl_layout_group_data_get_static_delegate;
3451
3452
3453     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_group_part_exist_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
3454
3455
3456     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_group_part_exist_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String part);
3457     public static Efl.Eo.FunctionWrapper<efl_layout_group_part_exist_get_api_delegate> efl_layout_group_part_exist_get_ptr = new Efl.Eo.FunctionWrapper<efl_layout_group_part_exist_get_api_delegate>(_Module, "efl_layout_group_part_exist_get");
3458     private static bool part_exist_get(System.IntPtr obj, System.IntPtr pd,   System.String part)
3459    {
3460       Eina.Log.Debug("function efl_layout_group_part_exist_get was called");
3461       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3462       if(wrapper != null) {
3463                                     bool _ret_var = default(bool);
3464          try {
3465             _ret_var = ((Layout)wrapper).GetPartExist( part);
3466          } catch (Exception e) {
3467             Eina.Log.Warning($"Callback error: {e.ToString()}");
3468             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3469          }
3470                   return _ret_var;
3471       } else {
3472          return efl_layout_group_part_exist_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
3473       }
3474    }
3475    private static efl_layout_group_part_exist_get_delegate efl_layout_group_part_exist_get_static_delegate;
3476
3477
3478     private delegate  void efl_layout_signal_message_send_delegate(System.IntPtr obj, System.IntPtr pd,    int id,    Eina.ValueNative msg);
3479
3480
3481     public delegate  void efl_layout_signal_message_send_api_delegate(System.IntPtr obj,    int id,    Eina.ValueNative msg);
3482     public static Efl.Eo.FunctionWrapper<efl_layout_signal_message_send_api_delegate> efl_layout_signal_message_send_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_message_send_api_delegate>(_Module, "efl_layout_signal_message_send");
3483     private static  void message_send(System.IntPtr obj, System.IntPtr pd,   int id,   Eina.ValueNative msg)
3484    {
3485       Eina.Log.Debug("function efl_layout_signal_message_send was called");
3486       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3487       if(wrapper != null) {
3488
3489          try {
3490             ((Layout)wrapper).MessageSend( id,  msg);
3491          } catch (Exception e) {
3492             Eina.Log.Warning($"Callback error: {e.ToString()}");
3493             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3494          }
3495                                     } else {
3496          efl_layout_signal_message_send_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id,  msg);
3497       }
3498    }
3499    private static efl_layout_signal_message_send_delegate efl_layout_signal_message_send_static_delegate;
3500
3501
3502     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_signal_callback_add_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
3503
3504
3505     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_signal_callback_add_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
3506     public static Efl.Eo.FunctionWrapper<efl_layout_signal_callback_add_api_delegate> efl_layout_signal_callback_add_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_callback_add_api_delegate>(_Module, "efl_layout_signal_callback_add");
3507     private static bool signal_callback_add(System.IntPtr obj, System.IntPtr pd,   System.String emission,   System.String source, IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb)
3508    {
3509       Eina.Log.Debug("function efl_layout_signal_callback_add was called");
3510       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3511       if(wrapper != null) {
3512                                                                   EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
3513          bool _ret_var = default(bool);
3514          try {
3515             _ret_var = ((Layout)wrapper).AddSignalCallback( emission,  source,  func_wrapper.ManagedCb);
3516          } catch (Exception e) {
3517             Eina.Log.Warning($"Callback error: {e.ToString()}");
3518             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3519          }
3520                                           return _ret_var;
3521       } else {
3522          return efl_layout_signal_callback_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source, func_data, func, func_free_cb);
3523       }
3524    }
3525    private static efl_layout_signal_callback_add_delegate efl_layout_signal_callback_add_static_delegate;
3526
3527
3528     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_signal_callback_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
3529
3530
3531     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_signal_callback_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
3532     public static Efl.Eo.FunctionWrapper<efl_layout_signal_callback_del_api_delegate> efl_layout_signal_callback_del_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_callback_del_api_delegate>(_Module, "efl_layout_signal_callback_del");
3533     private static bool signal_callback_del(System.IntPtr obj, System.IntPtr pd,   System.String emission,   System.String source, IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb)
3534    {
3535       Eina.Log.Debug("function efl_layout_signal_callback_del was called");
3536       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3537       if(wrapper != null) {
3538                                                                   EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
3539          bool _ret_var = default(bool);
3540          try {
3541             _ret_var = ((Layout)wrapper).DelSignalCallback( emission,  source,  func_wrapper.ManagedCb);
3542          } catch (Exception e) {
3543             Eina.Log.Warning($"Callback error: {e.ToString()}");
3544             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3545          }
3546                                           return _ret_var;
3547       } else {
3548          return efl_layout_signal_callback_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source, func_data, func, func_free_cb);
3549       }
3550    }
3551    private static efl_layout_signal_callback_del_delegate efl_layout_signal_callback_del_static_delegate;
3552
3553
3554     private delegate  void efl_layout_signal_emit_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source);
3555
3556
3557     public delegate  void efl_layout_signal_emit_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String source);
3558     public static Efl.Eo.FunctionWrapper<efl_layout_signal_emit_api_delegate> efl_layout_signal_emit_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_emit_api_delegate>(_Module, "efl_layout_signal_emit");
3559     private static  void signal_emit(System.IntPtr obj, System.IntPtr pd,   System.String emission,   System.String source)
3560    {
3561       Eina.Log.Debug("function efl_layout_signal_emit was called");
3562       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3563       if(wrapper != null) {
3564
3565          try {
3566             ((Layout)wrapper).EmitSignal( emission,  source);
3567          } catch (Exception e) {
3568             Eina.Log.Warning($"Callback error: {e.ToString()}");
3569             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3570          }
3571                                     } else {
3572          efl_layout_signal_emit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source);
3573       }
3574    }
3575    private static efl_layout_signal_emit_delegate efl_layout_signal_emit_static_delegate;
3576
3577
3578     private delegate  void efl_layout_signal_process_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool recurse);
3579
3580
3581     public delegate  void efl_layout_signal_process_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool recurse);
3582     public static Efl.Eo.FunctionWrapper<efl_layout_signal_process_api_delegate> efl_layout_signal_process_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_process_api_delegate>(_Module, "efl_layout_signal_process");
3583     private static  void signal_process(System.IntPtr obj, System.IntPtr pd,  bool recurse)
3584    {
3585       Eina.Log.Debug("function efl_layout_signal_process was called");
3586       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3587       if(wrapper != null) {
3588
3589          try {
3590             ((Layout)wrapper).SignalProcess( recurse);
3591          } catch (Exception e) {
3592             Eina.Log.Warning($"Callback error: {e.ToString()}");
3593             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3594          }
3595                         } else {
3596          efl_layout_signal_process_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  recurse);
3597       }
3598    }
3599    private static efl_layout_signal_process_delegate efl_layout_signal_process_static_delegate;
3600 }
3601 } }