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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Efl animation class</summary>
  13 [Efl.Canvas.Animation.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public class Animation : Efl.Object, Efl.IPlayable
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Animation))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  34         efl_canvas_animation_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Animation"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public Animation(Efl.Object parent= null
  38             ) : base(efl_canvas_animation_class_get(), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  44     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  45     protected Animation(ConstructingHandle ch) : base(ch)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Animation"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="wh">The native pointer to be wrapped.</param>
  52     protected Animation(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Animation"/> class.
  57     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  58     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Animation(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  61     {
  62     }
  63
  64     /// <summary>Keep final state property</summary>
  65     /// <returns><c>true</c> to keep final state, <c>false</c> otherwise.</returns>
  66     virtual public bool GetFinalStateKeep() {
  67          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_final_state_keep_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  68         Eina.Error.RaiseIfUnhandledException();
  69         return _ret_var;
  70  }
  71     /// <summary>Keep final state property</summary>
  72     /// <param name="keep"><c>true</c> to keep final state, <c>false</c> otherwise.</param>
  73     virtual public void SetFinalStateKeep(bool keep) {
  74                                  Efl.Canvas.Animation.NativeMethods.efl_animation_final_state_keep_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),keep);
  75         Eina.Error.RaiseIfUnhandledException();
  76                          }
  77     /// <summary>Duration property</summary>
  78     /// <returns>Duration value.</returns>
  79     virtual public double GetDuration() {
  80          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_duration_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  81         Eina.Error.RaiseIfUnhandledException();
  82         return _ret_var;
  83  }
  84     /// <summary>Duration property</summary>
  85     /// <param name="sec">Duration value.</param>
  86     virtual public void SetDuration(double sec) {
  87                                  Efl.Canvas.Animation.NativeMethods.efl_animation_duration_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),sec);
  88         Eina.Error.RaiseIfUnhandledException();
  89                          }
  90     /// <summary>Repeat mode property</summary>
  91     /// <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>
  92     virtual public Efl.Canvas.AnimationRepeatMode GetRepeatMode() {
  93          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_repeat_mode_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  94         Eina.Error.RaiseIfUnhandledException();
  95         return _ret_var;
  96  }
  97     /// <summary>Repeat mode property</summary>
  98     /// <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>
  99     virtual public void SetRepeatMode(Efl.Canvas.AnimationRepeatMode mode) {
 100                                  Efl.Canvas.Animation.NativeMethods.efl_animation_repeat_mode_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),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.Animation.NativeMethods.efl_animation_repeat_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 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     virtual public void SetRepeatCount(int count) {
 113                                  Efl.Canvas.Animation.NativeMethods.efl_animation_repeat_count_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),count);
 114         Eina.Error.RaiseIfUnhandledException();
 115                          }
 116     /// <summary>Start delay property</summary>
 117     /// <returns>Delay time, in seconds, from when the animation starts until the animation is animated</returns>
 118     virtual public double GetStartDelay() {
 119          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_start_delay_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 120         Eina.Error.RaiseIfUnhandledException();
 121         return _ret_var;
 122  }
 123     /// <summary>Start delay property</summary>
 124     /// <param name="sec">Delay time, in seconds, from when the animation starts until the animation is animated</param>
 125     virtual public void SetStartDelay(double sec) {
 126                                  Efl.Canvas.Animation.NativeMethods.efl_animation_start_delay_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),sec);
 127         Eina.Error.RaiseIfUnhandledException();
 128                          }
 129     /// <summary>Interpolator property</summary>
 130     /// <returns>Interpolator which indicates interpolation function. Efl_Interpolator is required.</returns>
 131     virtual public Efl.IInterpolator GetInterpolator() {
 132          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_interpolator_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 133         Eina.Error.RaiseIfUnhandledException();
 134         return _ret_var;
 135  }
 136     /// <summary>Interpolator property</summary>
 137     /// <param name="interpolator">Interpolator which indicates interpolation function. Efl_Interpolator is required.</param>
 138     virtual public void SetInterpolator(Efl.IInterpolator interpolator) {
 139                                  Efl.Canvas.Animation.NativeMethods.efl_animation_interpolator_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),interpolator);
 140         Eina.Error.RaiseIfUnhandledException();
 141                          }
 142     /// <returns>Final applied progress.</returns>
 143     virtual public double AnimationApply(double progress, Efl.Canvas.Object target) {
 144                                                          var _ret_var = Efl.Canvas.Animation.NativeMethods.efl_animation_apply_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),progress, target);
 145         Eina.Error.RaiseIfUnhandledException();
 146                                         return _ret_var;
 147  }
 148     /// <summary>Get the length of play for the media file.</summary>
 149     /// <returns>The length of the stream in seconds.</returns>
 150     virtual public double GetLength() {
 151          var _ret_var = Efl.IPlayableConcrete.NativeMethods.efl_playable_length_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 152         Eina.Error.RaiseIfUnhandledException();
 153         return _ret_var;
 154  }
 155     virtual public bool GetPlayable() {
 156          var _ret_var = Efl.IPlayableConcrete.NativeMethods.efl_playable_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 157         Eina.Error.RaiseIfUnhandledException();
 158         return _ret_var;
 159  }
 160     /// <summary>Get whether the media file is seekable.</summary>
 161     /// <returns><c>true</c> if seekable.</returns>
 162     virtual public bool GetSeekable() {
 163          var _ret_var = Efl.IPlayableConcrete.NativeMethods.efl_playable_seekable_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 164         Eina.Error.RaiseIfUnhandledException();
 165         return _ret_var;
 166  }
 167     /// <summary>Keep final state property</summary>
 168     /// <value><c>true</c> to keep final state, <c>false</c> otherwise.</value>
 169     public bool FinalStateKeep {
 170         get { return GetFinalStateKeep(); }
 171         set { SetFinalStateKeep(value); }
 172     }
 173     /// <summary>Duration property</summary>
 174     /// <value>Duration value.</value>
 175     public double Duration {
 176         get { return GetDuration(); }
 177         set { SetDuration(value); }
 178     }
 179     /// <summary>Repeat mode property</summary>
 180     /// <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>
 181     public Efl.Canvas.AnimationRepeatMode RepeatMode {
 182         get { return GetRepeatMode(); }
 183         set { SetRepeatMode(value); }
 184     }
 185     /// <summary>Repeat count property</summary>
 186     /// <value>Repeat count. EFL_ANIMATION_REPEAT_INFINITE repeats animation infinitely.</value>
 187     public int RepeatCount {
 188         get { return GetRepeatCount(); }
 189         set { SetRepeatCount(value); }
 190     }
 191     /// <summary>Start delay property</summary>
 192     /// <value>Delay time, in seconds, from when the animation starts until the animation is animated</value>
 193     public double StartDelay {
 194         get { return GetStartDelay(); }
 195         set { SetStartDelay(value); }
 196     }
 197     /// <summary>Interpolator property</summary>
 198     /// <value>Interpolator which indicates interpolation function. Efl_Interpolator is required.</value>
 199     public Efl.IInterpolator Interpolator {
 200         get { return GetInterpolator(); }
 201         set { SetInterpolator(value); }
 202     }
 203     /// <summary>Get the length of play for the media file.</summary>
 204     /// <value>The length of the stream in seconds.</value>
 205     public double Length {
 206         get { return GetLength(); }
 207     }
 208     public bool Playable {
 209         get { return GetPlayable(); }
 210     }
 211     /// <summary>Get whether the media file is seekable.</summary>
 212     /// <value><c>true</c> if seekable.</value>
 213     public bool Seekable {
 214         get { return GetSeekable(); }
 215     }
 216     private static IntPtr GetEflClassStatic()
 217     {
 218         return Efl.Canvas.Animation.efl_canvas_animation_class_get();
 219     }
 220     /// <summary>Wrapper for native methods and virtual method delegates.
 221     /// For internal use by generated code only.</summary>
 222     public new class NativeMethods : Efl.Object.NativeMethods
 223     {
 224         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 225         /// <summary>Gets the list of Eo operations to override.</summary>
 226         /// <returns>The list of Eo operations to be overload.</returns>
 227         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 228         {
 229             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 230             var methods = Efl.Eo.Globals.GetUserMethods(type);
 231
 232             if (efl_animation_final_state_keep_get_static_delegate == null)
 233             {
 234                 efl_animation_final_state_keep_get_static_delegate = new efl_animation_final_state_keep_get_delegate(final_state_keep_get);
 235             }
 236
 237             if (methods.FirstOrDefault(m => m.Name == "GetFinalStateKeep") != null)
 238             {
 239                 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) });
 240             }
 241
 242             if (efl_animation_final_state_keep_set_static_delegate == null)
 243             {
 244                 efl_animation_final_state_keep_set_static_delegate = new efl_animation_final_state_keep_set_delegate(final_state_keep_set);
 245             }
 246
 247             if (methods.FirstOrDefault(m => m.Name == "SetFinalStateKeep") != null)
 248             {
 249                 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) });
 250             }
 251
 252             if (efl_animation_duration_get_static_delegate == null)
 253             {
 254                 efl_animation_duration_get_static_delegate = new efl_animation_duration_get_delegate(duration_get);
 255             }
 256
 257             if (methods.FirstOrDefault(m => m.Name == "GetDuration") != null)
 258             {
 259                 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) });
 260             }
 261
 262             if (efl_animation_duration_set_static_delegate == null)
 263             {
 264                 efl_animation_duration_set_static_delegate = new efl_animation_duration_set_delegate(duration_set);
 265             }
 266
 267             if (methods.FirstOrDefault(m => m.Name == "SetDuration") != null)
 268             {
 269                 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) });
 270             }
 271
 272             if (efl_animation_repeat_mode_get_static_delegate == null)
 273             {
 274                 efl_animation_repeat_mode_get_static_delegate = new efl_animation_repeat_mode_get_delegate(repeat_mode_get);
 275             }
 276
 277             if (methods.FirstOrDefault(m => m.Name == "GetRepeatMode") != null)
 278             {
 279                 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) });
 280             }
 281
 282             if (efl_animation_repeat_mode_set_static_delegate == null)
 283             {
 284                 efl_animation_repeat_mode_set_static_delegate = new efl_animation_repeat_mode_set_delegate(repeat_mode_set);
 285             }
 286
 287             if (methods.FirstOrDefault(m => m.Name == "SetRepeatMode") != null)
 288             {
 289                 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) });
 290             }
 291
 292             if (efl_animation_repeat_count_get_static_delegate == null)
 293             {
 294                 efl_animation_repeat_count_get_static_delegate = new efl_animation_repeat_count_get_delegate(repeat_count_get);
 295             }
 296
 297             if (methods.FirstOrDefault(m => m.Name == "GetRepeatCount") != null)
 298             {
 299                 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) });
 300             }
 301
 302             if (efl_animation_repeat_count_set_static_delegate == null)
 303             {
 304                 efl_animation_repeat_count_set_static_delegate = new efl_animation_repeat_count_set_delegate(repeat_count_set);
 305             }
 306
 307             if (methods.FirstOrDefault(m => m.Name == "SetRepeatCount") != null)
 308             {
 309                 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) });
 310             }
 311
 312             if (efl_animation_start_delay_get_static_delegate == null)
 313             {
 314                 efl_animation_start_delay_get_static_delegate = new efl_animation_start_delay_get_delegate(start_delay_get);
 315             }
 316
 317             if (methods.FirstOrDefault(m => m.Name == "GetStartDelay") != null)
 318             {
 319                 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) });
 320             }
 321
 322             if (efl_animation_start_delay_set_static_delegate == null)
 323             {
 324                 efl_animation_start_delay_set_static_delegate = new efl_animation_start_delay_set_delegate(start_delay_set);
 325             }
 326
 327             if (methods.FirstOrDefault(m => m.Name == "SetStartDelay") != null)
 328             {
 329                 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) });
 330             }
 331
 332             if (efl_animation_interpolator_get_static_delegate == null)
 333             {
 334                 efl_animation_interpolator_get_static_delegate = new efl_animation_interpolator_get_delegate(interpolator_get);
 335             }
 336
 337             if (methods.FirstOrDefault(m => m.Name == "GetInterpolator") != null)
 338             {
 339                 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) });
 340             }
 341
 342             if (efl_animation_interpolator_set_static_delegate == null)
 343             {
 344                 efl_animation_interpolator_set_static_delegate = new efl_animation_interpolator_set_delegate(interpolator_set);
 345             }
 346
 347             if (methods.FirstOrDefault(m => m.Name == "SetInterpolator") != null)
 348             {
 349                 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) });
 350             }
 351
 352             if (efl_animation_apply_static_delegate == null)
 353             {
 354                 efl_animation_apply_static_delegate = new efl_animation_apply_delegate(animation_apply);
 355             }
 356
 357             if (methods.FirstOrDefault(m => m.Name == "AnimationApply") != null)
 358             {
 359                 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) });
 360             }
 361
 362             if (efl_playable_length_get_static_delegate == null)
 363             {
 364                 efl_playable_length_get_static_delegate = new efl_playable_length_get_delegate(length_get);
 365             }
 366
 367             if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 368             {
 369                 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) });
 370             }
 371
 372             if (efl_playable_get_static_delegate == null)
 373             {
 374                 efl_playable_get_static_delegate = new efl_playable_get_delegate(playable_get);
 375             }
 376
 377             if (methods.FirstOrDefault(m => m.Name == "GetPlayable") != null)
 378             {
 379                 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) });
 380             }
 381
 382             if (efl_playable_seekable_get_static_delegate == null)
 383             {
 384                 efl_playable_seekable_get_static_delegate = new efl_playable_seekable_get_delegate(seekable_get);
 385             }
 386
 387             if (methods.FirstOrDefault(m => m.Name == "GetSeekable") != null)
 388             {
 389                 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) });
 390             }
 391
 392             descs.AddRange(base.GetEoOps(type));
 393             return descs;
 394         }
 395         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 396         /// <returns>The native class pointer.</returns>
 397         public override IntPtr GetEflClass()
 398         {
 399             return Efl.Canvas.Animation.efl_canvas_animation_class_get();
 400         }
 401
 402         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 403
 404         [return: MarshalAs(UnmanagedType.U1)]
 405         private delegate bool efl_animation_final_state_keep_get_delegate(System.IntPtr obj, System.IntPtr pd);
 406
 407         [return: MarshalAs(UnmanagedType.U1)]
 408         public delegate bool efl_animation_final_state_keep_get_api_delegate(System.IntPtr obj);
 409
 410         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");
 411
 412         private static bool final_state_keep_get(System.IntPtr obj, System.IntPtr pd)
 413         {
 414             Eina.Log.Debug("function efl_animation_final_state_keep_get was called");
 415             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 416             if (ws != null)
 417             {
 418             bool _ret_var = default(bool);
 419                 try
 420                 {
 421                     _ret_var = ((Animation)ws.Target).GetFinalStateKeep();
 422                 }
 423                 catch (Exception e)
 424                 {
 425                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 426                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 427                 }
 428
 429         return _ret_var;
 430
 431             }
 432             else
 433             {
 434                 return efl_animation_final_state_keep_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 435             }
 436         }
 437
 438         private static efl_animation_final_state_keep_get_delegate efl_animation_final_state_keep_get_static_delegate;
 439
 440
 441         private delegate void efl_animation_final_state_keep_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool keep);
 442
 443
 444         public delegate void efl_animation_final_state_keep_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool keep);
 445
 446         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");
 447
 448         private static void final_state_keep_set(System.IntPtr obj, System.IntPtr pd, bool keep)
 449         {
 450             Eina.Log.Debug("function efl_animation_final_state_keep_set was called");
 451             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 452             if (ws != null)
 453             {
 454
 455                 try
 456                 {
 457                     ((Animation)ws.Target).SetFinalStateKeep(keep);
 458                 }
 459                 catch (Exception e)
 460                 {
 461                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 462                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 463                 }
 464
 465
 466             }
 467             else
 468             {
 469                 efl_animation_final_state_keep_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), keep);
 470             }
 471         }
 472
 473         private static efl_animation_final_state_keep_set_delegate efl_animation_final_state_keep_set_static_delegate;
 474
 475
 476         private delegate double efl_animation_duration_get_delegate(System.IntPtr obj, System.IntPtr pd);
 477
 478
 479         public delegate double efl_animation_duration_get_api_delegate(System.IntPtr obj);
 480
 481         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");
 482
 483         private static double duration_get(System.IntPtr obj, System.IntPtr pd)
 484         {
 485             Eina.Log.Debug("function efl_animation_duration_get was called");
 486             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 487             if (ws != null)
 488             {
 489             double _ret_var = default(double);
 490                 try
 491                 {
 492                     _ret_var = ((Animation)ws.Target).GetDuration();
 493                 }
 494                 catch (Exception e)
 495                 {
 496                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 497                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 498                 }
 499
 500         return _ret_var;
 501
 502             }
 503             else
 504             {
 505                 return efl_animation_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 506             }
 507         }
 508
 509         private static efl_animation_duration_get_delegate efl_animation_duration_get_static_delegate;
 510
 511
 512         private delegate void efl_animation_duration_set_delegate(System.IntPtr obj, System.IntPtr pd,  double sec);
 513
 514
 515         public delegate void efl_animation_duration_set_api_delegate(System.IntPtr obj,  double sec);
 516
 517         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");
 518
 519         private static void duration_set(System.IntPtr obj, System.IntPtr pd, double sec)
 520         {
 521             Eina.Log.Debug("function efl_animation_duration_set was called");
 522             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 523             if (ws != null)
 524             {
 525
 526                 try
 527                 {
 528                     ((Animation)ws.Target).SetDuration(sec);
 529                 }
 530                 catch (Exception e)
 531                 {
 532                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 533                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 534                 }
 535
 536
 537             }
 538             else
 539             {
 540                 efl_animation_duration_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sec);
 541             }
 542         }
 543
 544         private static efl_animation_duration_set_delegate efl_animation_duration_set_static_delegate;
 545
 546
 547         private delegate Efl.Canvas.AnimationRepeatMode efl_animation_repeat_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 548
 549
 550         public delegate Efl.Canvas.AnimationRepeatMode efl_animation_repeat_mode_get_api_delegate(System.IntPtr obj);
 551
 552         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");
 553
 554         private static Efl.Canvas.AnimationRepeatMode repeat_mode_get(System.IntPtr obj, System.IntPtr pd)
 555         {
 556             Eina.Log.Debug("function efl_animation_repeat_mode_get was called");
 557             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 558             if (ws != null)
 559             {
 560             Efl.Canvas.AnimationRepeatMode _ret_var = default(Efl.Canvas.AnimationRepeatMode);
 561                 try
 562                 {
 563                     _ret_var = ((Animation)ws.Target).GetRepeatMode();
 564                 }
 565                 catch (Exception e)
 566                 {
 567                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 568                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 569                 }
 570
 571         return _ret_var;
 572
 573             }
 574             else
 575             {
 576                 return efl_animation_repeat_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 577             }
 578         }
 579
 580         private static efl_animation_repeat_mode_get_delegate efl_animation_repeat_mode_get_static_delegate;
 581
 582
 583         private delegate void efl_animation_repeat_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.AnimationRepeatMode mode);
 584
 585
 586         public delegate void efl_animation_repeat_mode_set_api_delegate(System.IntPtr obj,  Efl.Canvas.AnimationRepeatMode mode);
 587
 588         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");
 589
 590         private static void repeat_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.AnimationRepeatMode mode)
 591         {
 592             Eina.Log.Debug("function efl_animation_repeat_mode_set was called");
 593             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 594             if (ws != null)
 595             {
 596
 597                 try
 598                 {
 599                     ((Animation)ws.Target).SetRepeatMode(mode);
 600                 }
 601                 catch (Exception e)
 602                 {
 603                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 604                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 605                 }
 606
 607
 608             }
 609             else
 610             {
 611                 efl_animation_repeat_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode);
 612             }
 613         }
 614
 615         private static efl_animation_repeat_mode_set_delegate efl_animation_repeat_mode_set_static_delegate;
 616
 617
 618         private delegate int efl_animation_repeat_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 619
 620
 621         public delegate int efl_animation_repeat_count_get_api_delegate(System.IntPtr obj);
 622
 623         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");
 624
 625         private static int repeat_count_get(System.IntPtr obj, System.IntPtr pd)
 626         {
 627             Eina.Log.Debug("function efl_animation_repeat_count_get was called");
 628             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 629             if (ws != null)
 630             {
 631             int _ret_var = default(int);
 632                 try
 633                 {
 634                     _ret_var = ((Animation)ws.Target).GetRepeatCount();
 635                 }
 636                 catch (Exception e)
 637                 {
 638                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 639                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 640                 }
 641
 642         return _ret_var;
 643
 644             }
 645             else
 646             {
 647                 return efl_animation_repeat_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 648             }
 649         }
 650
 651         private static efl_animation_repeat_count_get_delegate efl_animation_repeat_count_get_static_delegate;
 652
 653
 654         private delegate void efl_animation_repeat_count_set_delegate(System.IntPtr obj, System.IntPtr pd,  int count);
 655
 656
 657         public delegate void efl_animation_repeat_count_set_api_delegate(System.IntPtr obj,  int count);
 658
 659         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");
 660
 661         private static void repeat_count_set(System.IntPtr obj, System.IntPtr pd, int count)
 662         {
 663             Eina.Log.Debug("function efl_animation_repeat_count_set was called");
 664             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 665             if (ws != null)
 666             {
 667
 668                 try
 669                 {
 670                     ((Animation)ws.Target).SetRepeatCount(count);
 671                 }
 672                 catch (Exception e)
 673                 {
 674                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 675                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 676                 }
 677
 678
 679             }
 680             else
 681             {
 682                 efl_animation_repeat_count_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), count);
 683             }
 684         }
 685
 686         private static efl_animation_repeat_count_set_delegate efl_animation_repeat_count_set_static_delegate;
 687
 688
 689         private delegate double efl_animation_start_delay_get_delegate(System.IntPtr obj, System.IntPtr pd);
 690
 691
 692         public delegate double efl_animation_start_delay_get_api_delegate(System.IntPtr obj);
 693
 694         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");
 695
 696         private static double start_delay_get(System.IntPtr obj, System.IntPtr pd)
 697         {
 698             Eina.Log.Debug("function efl_animation_start_delay_get was called");
 699             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 700             if (ws != null)
 701             {
 702             double _ret_var = default(double);
 703                 try
 704                 {
 705                     _ret_var = ((Animation)ws.Target).GetStartDelay();
 706                 }
 707                 catch (Exception e)
 708                 {
 709                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 710                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 711                 }
 712
 713         return _ret_var;
 714
 715             }
 716             else
 717             {
 718                 return efl_animation_start_delay_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 719             }
 720         }
 721
 722         private static efl_animation_start_delay_get_delegate efl_animation_start_delay_get_static_delegate;
 723
 724
 725         private delegate void efl_animation_start_delay_set_delegate(System.IntPtr obj, System.IntPtr pd,  double sec);
 726
 727
 728         public delegate void efl_animation_start_delay_set_api_delegate(System.IntPtr obj,  double sec);
 729
 730         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");
 731
 732         private static void start_delay_set(System.IntPtr obj, System.IntPtr pd, double sec)
 733         {
 734             Eina.Log.Debug("function efl_animation_start_delay_set was called");
 735             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 736             if (ws != null)
 737             {
 738
 739                 try
 740                 {
 741                     ((Animation)ws.Target).SetStartDelay(sec);
 742                 }
 743                 catch (Exception e)
 744                 {
 745                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 746                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 747                 }
 748
 749
 750             }
 751             else
 752             {
 753                 efl_animation_start_delay_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sec);
 754             }
 755         }
 756
 757         private static efl_animation_start_delay_set_delegate efl_animation_start_delay_set_static_delegate;
 758
 759         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 760         private delegate Efl.IInterpolator efl_animation_interpolator_get_delegate(System.IntPtr obj, System.IntPtr pd);
 761
 762         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 763         public delegate Efl.IInterpolator efl_animation_interpolator_get_api_delegate(System.IntPtr obj);
 764
 765         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");
 766
 767         private static Efl.IInterpolator interpolator_get(System.IntPtr obj, System.IntPtr pd)
 768         {
 769             Eina.Log.Debug("function efl_animation_interpolator_get was called");
 770             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 771             if (ws != null)
 772             {
 773             Efl.IInterpolator _ret_var = default(Efl.IInterpolator);
 774                 try
 775                 {
 776                     _ret_var = ((Animation)ws.Target).GetInterpolator();
 777                 }
 778                 catch (Exception e)
 779                 {
 780                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 781                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 782                 }
 783
 784         return _ret_var;
 785
 786             }
 787             else
 788             {
 789                 return efl_animation_interpolator_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 790             }
 791         }
 792
 793         private static efl_animation_interpolator_get_delegate efl_animation_interpolator_get_static_delegate;
 794
 795
 796         private delegate void efl_animation_interpolator_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.IInterpolator interpolator);
 797
 798
 799         public delegate void efl_animation_interpolator_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.IInterpolator interpolator);
 800
 801         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");
 802
 803         private static void interpolator_set(System.IntPtr obj, System.IntPtr pd, Efl.IInterpolator interpolator)
 804         {
 805             Eina.Log.Debug("function efl_animation_interpolator_set was called");
 806             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 807             if (ws != null)
 808             {
 809
 810                 try
 811                 {
 812                     ((Animation)ws.Target).SetInterpolator(interpolator);
 813                 }
 814                 catch (Exception e)
 815                 {
 816                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 817                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 818                 }
 819
 820
 821             }
 822             else
 823             {
 824                 efl_animation_interpolator_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), interpolator);
 825             }
 826         }
 827
 828         private static efl_animation_interpolator_set_delegate efl_animation_interpolator_set_static_delegate;
 829
 830
 831         private delegate double efl_animation_apply_delegate(System.IntPtr obj, System.IntPtr pd,  double progress, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object target);
 832
 833
 834         public delegate double efl_animation_apply_api_delegate(System.IntPtr obj,  double progress, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object target);
 835
 836         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");
 837
 838         private static double animation_apply(System.IntPtr obj, System.IntPtr pd, double progress, Efl.Canvas.Object target)
 839         {
 840             Eina.Log.Debug("function efl_animation_apply was called");
 841             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 842             if (ws != null)
 843             {
 844                                                             double _ret_var = default(double);
 845                 try
 846                 {
 847                     _ret_var = ((Animation)ws.Target).AnimationApply(progress, target);
 848                 }
 849                 catch (Exception e)
 850                 {
 851                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 852                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 853                 }
 854
 855                                         return _ret_var;
 856
 857             }
 858             else
 859             {
 860                 return efl_animation_apply_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), progress, target);
 861             }
 862         }
 863
 864         private static efl_animation_apply_delegate efl_animation_apply_static_delegate;
 865
 866
 867         private delegate double efl_playable_length_get_delegate(System.IntPtr obj, System.IntPtr pd);
 868
 869
 870         public delegate double efl_playable_length_get_api_delegate(System.IntPtr obj);
 871
 872         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");
 873
 874         private static double length_get(System.IntPtr obj, System.IntPtr pd)
 875         {
 876             Eina.Log.Debug("function efl_playable_length_get was called");
 877             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 878             if (ws != null)
 879             {
 880             double _ret_var = default(double);
 881                 try
 882                 {
 883                     _ret_var = ((Animation)ws.Target).GetLength();
 884                 }
 885                 catch (Exception e)
 886                 {
 887                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 888                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 889                 }
 890
 891         return _ret_var;
 892
 893             }
 894             else
 895             {
 896                 return efl_playable_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 897             }
 898         }
 899
 900         private static efl_playable_length_get_delegate efl_playable_length_get_static_delegate;
 901
 902         [return: MarshalAs(UnmanagedType.U1)]
 903         private delegate bool efl_playable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 904
 905         [return: MarshalAs(UnmanagedType.U1)]
 906         public delegate bool efl_playable_get_api_delegate(System.IntPtr obj);
 907
 908         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");
 909
 910         private static bool playable_get(System.IntPtr obj, System.IntPtr pd)
 911         {
 912             Eina.Log.Debug("function efl_playable_get was called");
 913             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 914             if (ws != null)
 915             {
 916             bool _ret_var = default(bool);
 917                 try
 918                 {
 919                     _ret_var = ((Animation)ws.Target).GetPlayable();
 920                 }
 921                 catch (Exception e)
 922                 {
 923                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 924                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 925                 }
 926
 927         return _ret_var;
 928
 929             }
 930             else
 931             {
 932                 return efl_playable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 933             }
 934         }
 935
 936         private static efl_playable_get_delegate efl_playable_get_static_delegate;
 937
 938         [return: MarshalAs(UnmanagedType.U1)]
 939         private delegate bool efl_playable_seekable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 940
 941         [return: MarshalAs(UnmanagedType.U1)]
 942         public delegate bool efl_playable_seekable_get_api_delegate(System.IntPtr obj);
 943
 944         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");
 945
 946         private static bool seekable_get(System.IntPtr obj, System.IntPtr pd)
 947         {
 948             Eina.Log.Debug("function efl_playable_seekable_get was called");
 949             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 950             if (ws != null)
 951             {
 952             bool _ret_var = default(bool);
 953                 try
 954                 {
 955                     _ret_var = ((Animation)ws.Target).GetSeekable();
 956                 }
 957                 catch (Exception e)
 958                 {
 959                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 960                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 961                 }
 962
 963         return _ret_var;
 964
 965             }
 966             else
 967             {
 968                 return efl_playable_seekable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 969             }
 970         }
 971
 972         private static efl_playable_seekable_get_delegate efl_playable_seekable_get_static_delegate;
 973
 974         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 975
 976 }
 977 }
 978 }
 979
 980 }
 981