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