internals/src/EflSharp/EflSharp/efl/efl_canvas_animation.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>Efl animation class</summary>
   9 [AnimationNativeInherit]
  10 public class Animation : Efl.Object, Efl.Eo.IWrapper,Efl.IPlayable
  11 {
  12     ///<summary>Pointer to the native class description.</summary>
  13     public override System.IntPtr NativeClass {
  14         get {
  15             if (((object)this).GetType() == typeof (Animation))
  16                 return Efl.Canvas.AnimationNativeInherit.GetEflClassStatic();
  17             else
  18                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  19         }
  20     }
  21     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  22         efl_canvas_animation_class_get();
  23     ///<summary>Creates a new instance.</summary>
  24     ///<param name="parent">Parent instance.</param>
  25     public Animation(Efl.Object parent= null
  26             ) :
  27         base(efl_canvas_animation_class_get(), typeof(Animation), parent)
  28     {
  29         FinishInstantiation();
  30     }
  31     ///<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>
  32     protected Animation(System.IntPtr raw) : base(raw)
  33     {
  34                 RegisterEventProxies();
  35     }
  36     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  37     protected Animation(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  38     ///<summary>Verifies if the given object is equal to this one.</summary>
  39     public override bool Equals(object obj)
  40     {
  41         var other = obj as Efl.Object;
  42         if (other == null)
  43             return false;
  44         return this.NativeHandle == other.NativeHandle;
  45     }
  46     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  47     public override int GetHashCode()
  48     {
  49         return this.NativeHandle.ToInt32();
  50     }
  51     ///<summary>Turns the native pointer into a string representation.</summary>
  52     public override String ToString()
  53     {
  54         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  55     }
  56     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
  57     protected override void RegisterEventProxies()
  58     {
  59         base.RegisterEventProxies();
  60     }
  61     /// <summary>Keep final state property</summary>
  62     /// <returns><c>true</c> to keep final state, <c>false</c> otherwise.</returns>
  63     virtual public bool GetFinalStateKeep() {
  64          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_final_state_keep_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  65         Eina.Error.RaiseIfUnhandledException();
  66         return _ret_var;
  67  }
  68     /// <summary>Keep final state property</summary>
  69     /// <param name="keep"><c>true</c> to keep final state, <c>false</c> otherwise.</param>
  70     /// <returns></returns>
  71     virtual public void SetFinalStateKeep( bool keep) {
  72                                  Efl.Canvas.AnimationNativeInherit.efl_animation_final_state_keep_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), keep);
  73         Eina.Error.RaiseIfUnhandledException();
  74                          }
  75     /// <summary>Duration property</summary>
  76     /// <returns>Duration value.</returns>
  77     virtual public double GetDuration() {
  78          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_duration_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  79         Eina.Error.RaiseIfUnhandledException();
  80         return _ret_var;
  81  }
  82     /// <summary>Duration property</summary>
  83     /// <param name="sec">Duration value.</param>
  84     /// <returns></returns>
  85     virtual public void SetDuration( double sec) {
  86                                  Efl.Canvas.AnimationNativeInherit.efl_animation_duration_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sec);
  87         Eina.Error.RaiseIfUnhandledException();
  88                          }
  89     /// <summary>Repeat mode property</summary>
  90     /// <returns>Repeat mode. EFL_ANIMATION_REPEAT_MODE_RESTART restarts animation when the animation ends and EFL_ANIMATION_REPEAT_MODE_REVERSE reverses animation when the animation ends.</returns>
  91     virtual public Efl.Canvas.AnimationRepeatMode GetRepeatMode() {
  92          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_repeat_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  93         Eina.Error.RaiseIfUnhandledException();
  94         return _ret_var;
  95  }
  96     /// <summary>Repeat mode property</summary>
  97     /// <param name="mode">Repeat mode. EFL_ANIMATION_REPEAT_MODE_RESTART restarts animation when the animation ends and EFL_ANIMATION_REPEAT_MODE_REVERSE reverses animation when the animation ends.</param>
  98     /// <returns></returns>
  99     virtual public void SetRepeatMode( Efl.Canvas.AnimationRepeatMode mode) {
 100                                  Efl.Canvas.AnimationNativeInherit.efl_animation_repeat_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), mode);
 101         Eina.Error.RaiseIfUnhandledException();
 102                          }
 103     /// <summary>Repeat count property</summary>
 104     /// <returns>Repeat count. EFL_ANIMATION_REPEAT_INFINITE repeats animation infinitely.</returns>
 105     virtual public int GetRepeatCount() {
 106          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_repeat_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 107         Eina.Error.RaiseIfUnhandledException();
 108         return _ret_var;
 109  }
 110     /// <summary>Repeat count property</summary>
 111     /// <param name="count">Repeat count. EFL_ANIMATION_REPEAT_INFINITE repeats animation infinitely.</param>
 112     /// <returns></returns>
 113     virtual public void SetRepeatCount( int count) {
 114                                  Efl.Canvas.AnimationNativeInherit.efl_animation_repeat_count_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), count);
 115         Eina.Error.RaiseIfUnhandledException();
 116                          }
 117     /// <summary>Start delay property</summary>
 118     /// <returns>Delay time, in seconds, from when the animation starts until the animation is animated</returns>
 119     virtual public double GetStartDelay() {
 120          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_start_delay_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 121         Eina.Error.RaiseIfUnhandledException();
 122         return _ret_var;
 123  }
 124     /// <summary>Start delay property</summary>
 125     /// <param name="sec">Delay time, in seconds, from when the animation starts until the animation is animated</param>
 126     /// <returns></returns>
 127     virtual public void SetStartDelay( double sec) {
 128                                  Efl.Canvas.AnimationNativeInherit.efl_animation_start_delay_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sec);
 129         Eina.Error.RaiseIfUnhandledException();
 130                          }
 131     /// <summary>Interpolator property</summary>
 132     /// <returns>Interpolator which indicates interpolation function. Efl_Interpolator is required.</returns>
 133     virtual public Efl.IInterpolator GetInterpolator() {
 134          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_interpolator_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 135         Eina.Error.RaiseIfUnhandledException();
 136         return _ret_var;
 137  }
 138     /// <summary>Interpolator property</summary>
 139     /// <param name="interpolator">Interpolator which indicates interpolation function. Efl_Interpolator is required.</param>
 140     /// <returns></returns>
 141     virtual public void SetInterpolator( Efl.IInterpolator interpolator) {
 142                                  Efl.Canvas.AnimationNativeInherit.efl_animation_interpolator_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), interpolator);
 143         Eina.Error.RaiseIfUnhandledException();
 144                          }
 145     /// <summary></summary>
 146     /// <param name="progress"></param>
 147     /// <param name="target"></param>
 148     /// <returns>Final applied progress.</returns>
 149     virtual public double AnimationApply( double progress,  Efl.Canvas.Object target) {
 150                                                          var _ret_var = Efl.Canvas.AnimationNativeInherit.efl_animation_apply_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), progress,  target);
 151         Eina.Error.RaiseIfUnhandledException();
 152                                         return _ret_var;
 153  }
 154     /// <summary>Get the length of play for the media file.</summary>
 155     /// <returns>The length of the stream in seconds.</returns>
 156     virtual public double GetLength() {
 157          var _ret_var = Efl.IPlayableNativeInherit.efl_playable_length_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 158         Eina.Error.RaiseIfUnhandledException();
 159         return _ret_var;
 160  }
 161     /// <summary></summary>
 162     /// <returns></returns>
 163     virtual public bool GetPlayable() {
 164          var _ret_var = Efl.IPlayableNativeInherit.efl_playable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 165         Eina.Error.RaiseIfUnhandledException();
 166         return _ret_var;
 167  }
 168     /// <summary>Get whether the media file is seekable.</summary>
 169     /// <returns><c>true</c> if seekable.</returns>
 170     virtual public bool GetSeekable() {
 171          var _ret_var = Efl.IPlayableNativeInherit.efl_playable_seekable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 172         Eina.Error.RaiseIfUnhandledException();
 173         return _ret_var;
 174  }
 175     /// <summary>Keep final state property</summary>
 176 /// <value><c>true</c> to keep final state, <c>false</c> otherwise.</value>
 177     public bool FinalStateKeep {
 178         get { return GetFinalStateKeep(); }
 179         set { SetFinalStateKeep( value); }
 180     }
 181     /// <summary>Duration property</summary>
 182 /// <value>Duration value.</value>
 183     public double Duration {
 184         get { return GetDuration(); }
 185         set { SetDuration( value); }
 186     }
 187     /// <summary>Repeat mode property</summary>
 188 /// <value>Repeat mode. EFL_ANIMATION_REPEAT_MODE_RESTART restarts animation when the animation ends and EFL_ANIMATION_REPEAT_MODE_REVERSE reverses animation when the animation ends.</value>
 189     public Efl.Canvas.AnimationRepeatMode RepeatMode {
 190         get { return GetRepeatMode(); }
 191         set { SetRepeatMode( value); }
 192     }
 193     /// <summary>Repeat count property</summary>
 194 /// <value>Repeat count. EFL_ANIMATION_REPEAT_INFINITE repeats animation infinitely.</value>
 195     public int RepeatCount {
 196         get { return GetRepeatCount(); }
 197         set { SetRepeatCount( value); }
 198     }
 199     /// <summary>Start delay property</summary>
 200 /// <value>Delay time, in seconds, from when the animation starts until the animation is animated</value>
 201     public double StartDelay {
 202         get { return GetStartDelay(); }
 203         set { SetStartDelay( value); }
 204     }
 205     /// <summary>Interpolator property</summary>
 206 /// <value>Interpolator which indicates interpolation function. Efl_Interpolator is required.</value>
 207     public Efl.IInterpolator Interpolator {
 208         get { return GetInterpolator(); }
 209         set { SetInterpolator( value); }
 210     }
 211     /// <summary>Get the length of play for the media file.</summary>
 212 /// <value>The length of the stream in seconds.</value>
 213     public double Length {
 214         get { return GetLength(); }
 215     }
 216     /// <summary></summary>
 217 /// <value></value>
 218     public bool Playable {
 219         get { return GetPlayable(); }
 220     }
 221     /// <summary>Get whether the media file is seekable.</summary>
 222 /// <value><c>true</c> if seekable.</value>
 223     public bool Seekable {
 224         get { return GetSeekable(); }
 225     }
 226     private static IntPtr GetEflClassStatic()
 227     {
 228         return Efl.Canvas.Animation.efl_canvas_animation_class_get();
 229     }
 230 }
 231 public class AnimationNativeInherit : Efl.ObjectNativeInherit{
 232     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Evas);
 233     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 234     {
 235         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 236         var methods = Efl.Eo.Globals.GetUserMethods(type);
 237         if (efl_animation_final_state_keep_get_static_delegate == null)
 238             efl_animation_final_state_keep_get_static_delegate = new efl_animation_final_state_keep_get_delegate(final_state_keep_get);
 239         if (methods.FirstOrDefault(m => m.Name == "GetFinalStateKeep") != null)
 240             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_final_state_keep_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_final_state_keep_get_static_delegate)});
 241         if (efl_animation_final_state_keep_set_static_delegate == null)
 242             efl_animation_final_state_keep_set_static_delegate = new efl_animation_final_state_keep_set_delegate(final_state_keep_set);
 243         if (methods.FirstOrDefault(m => m.Name == "SetFinalStateKeep") != null)
 244             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_final_state_keep_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_final_state_keep_set_static_delegate)});
 245         if (efl_animation_duration_get_static_delegate == null)
 246             efl_animation_duration_get_static_delegate = new efl_animation_duration_get_delegate(duration_get);
 247         if (methods.FirstOrDefault(m => m.Name == "GetDuration") != null)
 248             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_duration_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_duration_get_static_delegate)});
 249         if (efl_animation_duration_set_static_delegate == null)
 250             efl_animation_duration_set_static_delegate = new efl_animation_duration_set_delegate(duration_set);
 251         if (methods.FirstOrDefault(m => m.Name == "SetDuration") != null)
 252             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_duration_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_duration_set_static_delegate)});
 253         if (efl_animation_repeat_mode_get_static_delegate == null)
 254             efl_animation_repeat_mode_get_static_delegate = new efl_animation_repeat_mode_get_delegate(repeat_mode_get);
 255         if (methods.FirstOrDefault(m => m.Name == "GetRepeatMode") != null)
 256             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_repeat_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_repeat_mode_get_static_delegate)});
 257         if (efl_animation_repeat_mode_set_static_delegate == null)
 258             efl_animation_repeat_mode_set_static_delegate = new efl_animation_repeat_mode_set_delegate(repeat_mode_set);
 259         if (methods.FirstOrDefault(m => m.Name == "SetRepeatMode") != null)
 260             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_repeat_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_repeat_mode_set_static_delegate)});
 261         if (efl_animation_repeat_count_get_static_delegate == null)
 262             efl_animation_repeat_count_get_static_delegate = new efl_animation_repeat_count_get_delegate(repeat_count_get);
 263         if (methods.FirstOrDefault(m => m.Name == "GetRepeatCount") != null)
 264             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_repeat_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_repeat_count_get_static_delegate)});
 265         if (efl_animation_repeat_count_set_static_delegate == null)
 266             efl_animation_repeat_count_set_static_delegate = new efl_animation_repeat_count_set_delegate(repeat_count_set);
 267         if (methods.FirstOrDefault(m => m.Name == "SetRepeatCount") != null)
 268             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_repeat_count_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_repeat_count_set_static_delegate)});
 269         if (efl_animation_start_delay_get_static_delegate == null)
 270             efl_animation_start_delay_get_static_delegate = new efl_animation_start_delay_get_delegate(start_delay_get);
 271         if (methods.FirstOrDefault(m => m.Name == "GetStartDelay") != null)
 272             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_start_delay_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_start_delay_get_static_delegate)});
 273         if (efl_animation_start_delay_set_static_delegate == null)
 274             efl_animation_start_delay_set_static_delegate = new efl_animation_start_delay_set_delegate(start_delay_set);
 275         if (methods.FirstOrDefault(m => m.Name == "SetStartDelay") != null)
 276             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_start_delay_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_start_delay_set_static_delegate)});
 277         if (efl_animation_interpolator_get_static_delegate == null)
 278             efl_animation_interpolator_get_static_delegate = new efl_animation_interpolator_get_delegate(interpolator_get);
 279         if (methods.FirstOrDefault(m => m.Name == "GetInterpolator") != null)
 280             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_interpolator_get"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_interpolator_get_static_delegate)});
 281         if (efl_animation_interpolator_set_static_delegate == null)
 282             efl_animation_interpolator_set_static_delegate = new efl_animation_interpolator_set_delegate(interpolator_set);
 283         if (methods.FirstOrDefault(m => m.Name == "SetInterpolator") != null)
 284             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_interpolator_set"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_interpolator_set_static_delegate)});
 285         if (efl_animation_apply_static_delegate == null)
 286             efl_animation_apply_static_delegate = new efl_animation_apply_delegate(animation_apply);
 287         if (methods.FirstOrDefault(m => m.Name == "AnimationApply") != null)
 288             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_animation_apply"), func = Marshal.GetFunctionPointerForDelegate(efl_animation_apply_static_delegate)});
 289         if (efl_playable_length_get_static_delegate == null)
 290             efl_playable_length_get_static_delegate = new efl_playable_length_get_delegate(length_get);
 291         if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 292             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_playable_length_get"), func = Marshal.GetFunctionPointerForDelegate(efl_playable_length_get_static_delegate)});
 293         if (efl_playable_get_static_delegate == null)
 294             efl_playable_get_static_delegate = new efl_playable_get_delegate(playable_get);
 295         if (methods.FirstOrDefault(m => m.Name == "GetPlayable") != null)
 296             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_playable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_playable_get_static_delegate)});
 297         if (efl_playable_seekable_get_static_delegate == null)
 298             efl_playable_seekable_get_static_delegate = new efl_playable_seekable_get_delegate(seekable_get);
 299         if (methods.FirstOrDefault(m => m.Name == "GetSeekable") != null)
 300             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_playable_seekable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_playable_seekable_get_static_delegate)});
 301         descs.AddRange(base.GetEoOps(type));
 302         return descs;
 303     }
 304     public override IntPtr GetEflClass()
 305     {
 306         return Efl.Canvas.Animation.efl_canvas_animation_class_get();
 307     }
 308     public static new  IntPtr GetEflClassStatic()
 309     {
 310         return Efl.Canvas.Animation.efl_canvas_animation_class_get();
 311     }
 312
 313
 314      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_animation_final_state_keep_get_delegate(System.IntPtr obj, System.IntPtr pd);
 315
 316
 317      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_animation_final_state_keep_get_api_delegate(System.IntPtr obj);
 318      public static Efl.Eo.FunctionWrapper<efl_animation_final_state_keep_get_api_delegate> efl_animation_final_state_keep_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_final_state_keep_get_api_delegate>(_Module, "efl_animation_final_state_keep_get");
 319      private static bool final_state_keep_get(System.IntPtr obj, System.IntPtr pd)
 320     {
 321         Eina.Log.Debug("function efl_animation_final_state_keep_get was called");
 322         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 323         if(wrapper != null) {
 324                         bool _ret_var = default(bool);
 325             try {
 326                 _ret_var = ((Animation)wrapper).GetFinalStateKeep();
 327             } catch (Exception e) {
 328                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 329                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 330             }
 331         return _ret_var;
 332         } else {
 333             return efl_animation_final_state_keep_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 334         }
 335     }
 336     private static efl_animation_final_state_keep_get_delegate efl_animation_final_state_keep_get_static_delegate;
 337
 338
 339      private delegate void efl_animation_final_state_keep_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool keep);
 340
 341
 342      public delegate void efl_animation_final_state_keep_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool keep);
 343      public static Efl.Eo.FunctionWrapper<efl_animation_final_state_keep_set_api_delegate> efl_animation_final_state_keep_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_final_state_keep_set_api_delegate>(_Module, "efl_animation_final_state_keep_set");
 344      private static void final_state_keep_set(System.IntPtr obj, System.IntPtr pd,  bool keep)
 345     {
 346         Eina.Log.Debug("function efl_animation_final_state_keep_set was called");
 347         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 348         if(wrapper != null) {
 349
 350             try {
 351                 ((Animation)wrapper).SetFinalStateKeep( keep);
 352             } catch (Exception e) {
 353                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 354                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 355             }
 356                                 } else {
 357             efl_animation_final_state_keep_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  keep);
 358         }
 359     }
 360     private static efl_animation_final_state_keep_set_delegate efl_animation_final_state_keep_set_static_delegate;
 361
 362
 363      private delegate double efl_animation_duration_get_delegate(System.IntPtr obj, System.IntPtr pd);
 364
 365
 366      public delegate double efl_animation_duration_get_api_delegate(System.IntPtr obj);
 367      public static Efl.Eo.FunctionWrapper<efl_animation_duration_get_api_delegate> efl_animation_duration_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_duration_get_api_delegate>(_Module, "efl_animation_duration_get");
 368      private static double duration_get(System.IntPtr obj, System.IntPtr pd)
 369     {
 370         Eina.Log.Debug("function efl_animation_duration_get was called");
 371         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 372         if(wrapper != null) {
 373                         double _ret_var = default(double);
 374             try {
 375                 _ret_var = ((Animation)wrapper).GetDuration();
 376             } catch (Exception e) {
 377                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 378                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 379             }
 380         return _ret_var;
 381         } else {
 382             return efl_animation_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 383         }
 384     }
 385     private static efl_animation_duration_get_delegate efl_animation_duration_get_static_delegate;
 386
 387
 388      private delegate void efl_animation_duration_set_delegate(System.IntPtr obj, System.IntPtr pd,   double sec);
 389
 390
 391      public delegate void efl_animation_duration_set_api_delegate(System.IntPtr obj,   double sec);
 392      public static Efl.Eo.FunctionWrapper<efl_animation_duration_set_api_delegate> efl_animation_duration_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_duration_set_api_delegate>(_Module, "efl_animation_duration_set");
 393      private static void duration_set(System.IntPtr obj, System.IntPtr pd,  double sec)
 394     {
 395         Eina.Log.Debug("function efl_animation_duration_set was called");
 396         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 397         if(wrapper != null) {
 398
 399             try {
 400                 ((Animation)wrapper).SetDuration( sec);
 401             } catch (Exception e) {
 402                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 403                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 404             }
 405                                 } else {
 406             efl_animation_duration_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sec);
 407         }
 408     }
 409     private static efl_animation_duration_set_delegate efl_animation_duration_set_static_delegate;
 410
 411
 412      private delegate Efl.Canvas.AnimationRepeatMode efl_animation_repeat_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 413
 414
 415      public delegate Efl.Canvas.AnimationRepeatMode efl_animation_repeat_mode_get_api_delegate(System.IntPtr obj);
 416      public static Efl.Eo.FunctionWrapper<efl_animation_repeat_mode_get_api_delegate> efl_animation_repeat_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_repeat_mode_get_api_delegate>(_Module, "efl_animation_repeat_mode_get");
 417      private static Efl.Canvas.AnimationRepeatMode repeat_mode_get(System.IntPtr obj, System.IntPtr pd)
 418     {
 419         Eina.Log.Debug("function efl_animation_repeat_mode_get was called");
 420         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 421         if(wrapper != null) {
 422                         Efl.Canvas.AnimationRepeatMode _ret_var = default(Efl.Canvas.AnimationRepeatMode);
 423             try {
 424                 _ret_var = ((Animation)wrapper).GetRepeatMode();
 425             } catch (Exception e) {
 426                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 427                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 428             }
 429         return _ret_var;
 430         } else {
 431             return efl_animation_repeat_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 432         }
 433     }
 434     private static efl_animation_repeat_mode_get_delegate efl_animation_repeat_mode_get_static_delegate;
 435
 436
 437      private delegate void efl_animation_repeat_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Canvas.AnimationRepeatMode mode);
 438
 439
 440      public delegate void efl_animation_repeat_mode_set_api_delegate(System.IntPtr obj,   Efl.Canvas.AnimationRepeatMode mode);
 441      public static Efl.Eo.FunctionWrapper<efl_animation_repeat_mode_set_api_delegate> efl_animation_repeat_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_repeat_mode_set_api_delegate>(_Module, "efl_animation_repeat_mode_set");
 442      private static void repeat_mode_set(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.AnimationRepeatMode mode)
 443     {
 444         Eina.Log.Debug("function efl_animation_repeat_mode_set was called");
 445         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 446         if(wrapper != null) {
 447
 448             try {
 449                 ((Animation)wrapper).SetRepeatMode( mode);
 450             } catch (Exception e) {
 451                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 452                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 453             }
 454                                 } else {
 455             efl_animation_repeat_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mode);
 456         }
 457     }
 458     private static efl_animation_repeat_mode_set_delegate efl_animation_repeat_mode_set_static_delegate;
 459
 460
 461      private delegate int efl_animation_repeat_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 462
 463
 464      public delegate int efl_animation_repeat_count_get_api_delegate(System.IntPtr obj);
 465      public static Efl.Eo.FunctionWrapper<efl_animation_repeat_count_get_api_delegate> efl_animation_repeat_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_repeat_count_get_api_delegate>(_Module, "efl_animation_repeat_count_get");
 466      private static int repeat_count_get(System.IntPtr obj, System.IntPtr pd)
 467     {
 468         Eina.Log.Debug("function efl_animation_repeat_count_get was called");
 469         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 470         if(wrapper != null) {
 471                         int _ret_var = default(int);
 472             try {
 473                 _ret_var = ((Animation)wrapper).GetRepeatCount();
 474             } catch (Exception e) {
 475                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 476                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 477             }
 478         return _ret_var;
 479         } else {
 480             return efl_animation_repeat_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 481         }
 482     }
 483     private static efl_animation_repeat_count_get_delegate efl_animation_repeat_count_get_static_delegate;
 484
 485
 486      private delegate void efl_animation_repeat_count_set_delegate(System.IntPtr obj, System.IntPtr pd,   int count);
 487
 488
 489      public delegate void efl_animation_repeat_count_set_api_delegate(System.IntPtr obj,   int count);
 490      public static Efl.Eo.FunctionWrapper<efl_animation_repeat_count_set_api_delegate> efl_animation_repeat_count_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_repeat_count_set_api_delegate>(_Module, "efl_animation_repeat_count_set");
 491      private static void repeat_count_set(System.IntPtr obj, System.IntPtr pd,  int count)
 492     {
 493         Eina.Log.Debug("function efl_animation_repeat_count_set was called");
 494         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 495         if(wrapper != null) {
 496
 497             try {
 498                 ((Animation)wrapper).SetRepeatCount( count);
 499             } catch (Exception e) {
 500                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 501                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 502             }
 503                                 } else {
 504             efl_animation_repeat_count_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  count);
 505         }
 506     }
 507     private static efl_animation_repeat_count_set_delegate efl_animation_repeat_count_set_static_delegate;
 508
 509
 510      private delegate double efl_animation_start_delay_get_delegate(System.IntPtr obj, System.IntPtr pd);
 511
 512
 513      public delegate double efl_animation_start_delay_get_api_delegate(System.IntPtr obj);
 514      public static Efl.Eo.FunctionWrapper<efl_animation_start_delay_get_api_delegate> efl_animation_start_delay_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_start_delay_get_api_delegate>(_Module, "efl_animation_start_delay_get");
 515      private static double start_delay_get(System.IntPtr obj, System.IntPtr pd)
 516     {
 517         Eina.Log.Debug("function efl_animation_start_delay_get was called");
 518         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 519         if(wrapper != null) {
 520                         double _ret_var = default(double);
 521             try {
 522                 _ret_var = ((Animation)wrapper).GetStartDelay();
 523             } catch (Exception e) {
 524                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 525                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 526             }
 527         return _ret_var;
 528         } else {
 529             return efl_animation_start_delay_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 530         }
 531     }
 532     private static efl_animation_start_delay_get_delegate efl_animation_start_delay_get_static_delegate;
 533
 534
 535      private delegate void efl_animation_start_delay_set_delegate(System.IntPtr obj, System.IntPtr pd,   double sec);
 536
 537
 538      public delegate void efl_animation_start_delay_set_api_delegate(System.IntPtr obj,   double sec);
 539      public static Efl.Eo.FunctionWrapper<efl_animation_start_delay_set_api_delegate> efl_animation_start_delay_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_start_delay_set_api_delegate>(_Module, "efl_animation_start_delay_set");
 540      private static void start_delay_set(System.IntPtr obj, System.IntPtr pd,  double sec)
 541     {
 542         Eina.Log.Debug("function efl_animation_start_delay_set was called");
 543         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 544         if(wrapper != null) {
 545
 546             try {
 547                 ((Animation)wrapper).SetStartDelay( sec);
 548             } catch (Exception e) {
 549                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 550                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 551             }
 552                                 } else {
 553             efl_animation_start_delay_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sec);
 554         }
 555     }
 556     private static efl_animation_start_delay_set_delegate efl_animation_start_delay_set_static_delegate;
 557
 558
 559     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IInterpolatorConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.IInterpolator efl_animation_interpolator_get_delegate(System.IntPtr obj, System.IntPtr pd);
 560
 561
 562     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IInterpolatorConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.IInterpolator efl_animation_interpolator_get_api_delegate(System.IntPtr obj);
 563      public static Efl.Eo.FunctionWrapper<efl_animation_interpolator_get_api_delegate> efl_animation_interpolator_get_ptr = new Efl.Eo.FunctionWrapper<efl_animation_interpolator_get_api_delegate>(_Module, "efl_animation_interpolator_get");
 564      private static Efl.IInterpolator interpolator_get(System.IntPtr obj, System.IntPtr pd)
 565     {
 566         Eina.Log.Debug("function efl_animation_interpolator_get was called");
 567         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 568         if(wrapper != null) {
 569                         Efl.IInterpolator _ret_var = default(Efl.IInterpolator);
 570             try {
 571                 _ret_var = ((Animation)wrapper).GetInterpolator();
 572             } catch (Exception e) {
 573                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 574                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 575             }
 576         return _ret_var;
 577         } else {
 578             return efl_animation_interpolator_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 579         }
 580     }
 581     private static efl_animation_interpolator_get_delegate efl_animation_interpolator_get_static_delegate;
 582
 583
 584      private delegate void efl_animation_interpolator_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IInterpolatorConcrete, Efl.Eo.NonOwnTag>))]  Efl.IInterpolator interpolator);
 585
 586
 587      public delegate void efl_animation_interpolator_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IInterpolatorConcrete, Efl.Eo.NonOwnTag>))]  Efl.IInterpolator interpolator);
 588      public static Efl.Eo.FunctionWrapper<efl_animation_interpolator_set_api_delegate> efl_animation_interpolator_set_ptr = new Efl.Eo.FunctionWrapper<efl_animation_interpolator_set_api_delegate>(_Module, "efl_animation_interpolator_set");
 589      private static void interpolator_set(System.IntPtr obj, System.IntPtr pd,  Efl.IInterpolator interpolator)
 590     {
 591         Eina.Log.Debug("function efl_animation_interpolator_set was called");
 592         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 593         if(wrapper != null) {
 594
 595             try {
 596                 ((Animation)wrapper).SetInterpolator( interpolator);
 597             } catch (Exception e) {
 598                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 599                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 600             }
 601                                 } else {
 602             efl_animation_interpolator_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  interpolator);
 603         }
 604     }
 605     private static efl_animation_interpolator_set_delegate efl_animation_interpolator_set_static_delegate;
 606
 607
 608      private delegate double efl_animation_apply_delegate(System.IntPtr obj, System.IntPtr pd,   double progress, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object target);
 609
 610
 611      public delegate double efl_animation_apply_api_delegate(System.IntPtr obj,   double progress, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object target);
 612      public static Efl.Eo.FunctionWrapper<efl_animation_apply_api_delegate> efl_animation_apply_ptr = new Efl.Eo.FunctionWrapper<efl_animation_apply_api_delegate>(_Module, "efl_animation_apply");
 613      private static double animation_apply(System.IntPtr obj, System.IntPtr pd,  double progress,  Efl.Canvas.Object target)
 614     {
 615         Eina.Log.Debug("function efl_animation_apply was called");
 616         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 617         if(wrapper != null) {
 618                                                                         double _ret_var = default(double);
 619             try {
 620                 _ret_var = ((Animation)wrapper).AnimationApply( progress,  target);
 621             } catch (Exception e) {
 622                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 623                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 624             }
 625                                         return _ret_var;
 626         } else {
 627             return efl_animation_apply_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  progress,  target);
 628         }
 629     }
 630     private static efl_animation_apply_delegate efl_animation_apply_static_delegate;
 631
 632
 633      private delegate double efl_playable_length_get_delegate(System.IntPtr obj, System.IntPtr pd);
 634
 635
 636      public delegate double efl_playable_length_get_api_delegate(System.IntPtr obj);
 637      public static Efl.Eo.FunctionWrapper<efl_playable_length_get_api_delegate> efl_playable_length_get_ptr = new Efl.Eo.FunctionWrapper<efl_playable_length_get_api_delegate>(_Module, "efl_playable_length_get");
 638      private static double length_get(System.IntPtr obj, System.IntPtr pd)
 639     {
 640         Eina.Log.Debug("function efl_playable_length_get was called");
 641         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 642         if(wrapper != null) {
 643                         double _ret_var = default(double);
 644             try {
 645                 _ret_var = ((Animation)wrapper).GetLength();
 646             } catch (Exception e) {
 647                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 648                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 649             }
 650         return _ret_var;
 651         } else {
 652             return efl_playable_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 653         }
 654     }
 655     private static efl_playable_length_get_delegate efl_playable_length_get_static_delegate;
 656
 657
 658      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_playable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 659
 660
 661      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_playable_get_api_delegate(System.IntPtr obj);
 662      public static Efl.Eo.FunctionWrapper<efl_playable_get_api_delegate> efl_playable_get_ptr = new Efl.Eo.FunctionWrapper<efl_playable_get_api_delegate>(_Module, "efl_playable_get");
 663      private static bool playable_get(System.IntPtr obj, System.IntPtr pd)
 664     {
 665         Eina.Log.Debug("function efl_playable_get was called");
 666         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 667         if(wrapper != null) {
 668                         bool _ret_var = default(bool);
 669             try {
 670                 _ret_var = ((Animation)wrapper).GetPlayable();
 671             } catch (Exception e) {
 672                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 673                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 674             }
 675         return _ret_var;
 676         } else {
 677             return efl_playable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 678         }
 679     }
 680     private static efl_playable_get_delegate efl_playable_get_static_delegate;
 681
 682
 683      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_playable_seekable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 684
 685
 686      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_playable_seekable_get_api_delegate(System.IntPtr obj);
 687      public static Efl.Eo.FunctionWrapper<efl_playable_seekable_get_api_delegate> efl_playable_seekable_get_ptr = new Efl.Eo.FunctionWrapper<efl_playable_seekable_get_api_delegate>(_Module, "efl_playable_seekable_get");
 688      private static bool seekable_get(System.IntPtr obj, System.IntPtr pd)
 689     {
 690         Eina.Log.Debug("function efl_playable_seekable_get was called");
 691         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 692         if(wrapper != null) {
 693                         bool _ret_var = default(bool);
 694             try {
 695                 _ret_var = ((Animation)wrapper).GetSeekable();
 696             } catch (Exception e) {
 697                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 698                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 699             }
 700         return _ret_var;
 701         } else {
 702             return efl_playable_seekable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 703         }
 704     }
 705     private static efl_playable_seekable_get_delegate efl_playable_seekable_get_static_delegate;
 706 }
 707 } }