internals/src/EflSharp/EflSharp/efl/efl_gfx_frame_controller.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 Gfx {
  11
  12 /// <summary>Efl frame controller of frame based animated object interface.</summary>
  13 [Efl.Gfx.IFrameControllerConcrete.NativeMethods]
  14 public interface IFrameController :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Check if an object can be animated (has multiple frames).
  18 /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
  19 /// <returns><c>true</c> if the object is animated</returns>
  20 bool GetAnimated();
  21     /// <summary>Index of the current frame of an animated object.
  22 /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
  23 /// <returns>The index of current frame.</returns>
  24 int GetFrame();
  25     /// <summary>Set the frame to current frame of an animated object.</summary>
  26 /// <param name="frame_index">The index of current frame.</param>
  27 /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
  28 bool SetFrame(int frame_index);
  29     /// <summary>Get the total number of frames of the object, if animated.
  30 /// Returns -1 if not animated.</summary>
  31 /// <returns>The number of frames in the animated object.</returns>
  32 int GetFrameCount();
  33     /// <summary>Get the kind of looping the animated object does.
  34 /// This returns the kind of looping the animated object wants to do.
  35 ///
  36 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
  37 ///
  38 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
  39 ///
  40 /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
  41 /// <returns>Loop type of the animated object.</returns>
  42 Efl.Gfx.FrameControllerLoopHint GetLoopType();
  43     /// <summary>Get the number times the animation of the object loops.
  44 /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
  45 ///
  46 /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
  47 /// <returns>The number of loop of an animated object.</returns>
  48 int GetLoopCount();
  49     /// <summary>Get the duration of a sequence of frames.
  50 /// This returns total duration in seconds that the specified sequence of frames should take.
  51 ///
  52 /// If <c>start_frame</c> is 1 and <c>frame_num</c> is 0, this returns the duration of frame 1. If <c>start_frame</c> is 1 and <c>frame_num</c> is 1, this returns the total duration of frame 1 + frame 2.</summary>
  53 /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
  54 /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
  55 /// <returns>Duration in seconds</returns>
  56 double GetFrameDuration(int start_frame, int frame_num);
  57                                 /// <summary>Check if an object can be animated (has multiple frames).
  58 /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
  59 /// <value><c>true</c> if the object is animated</value>
  60     bool Animated {
  61         get ;
  62     }
  63     /// <summary>Index of the current frame of an animated object.
  64 /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
  65 /// <value>The index of current frame.</value>
  66     int Frame {
  67         get ;
  68         set ;
  69     }
  70     /// <summary>Get the total number of frames of the object, if animated.
  71 /// Returns -1 if not animated.</summary>
  72 /// <value>The number of frames in the animated object.</value>
  73     int FrameCount {
  74         get ;
  75     }
  76     /// <summary>Get the kind of looping the animated object does.
  77 /// This returns the kind of looping the animated object wants to do.
  78 ///
  79 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
  80 ///
  81 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
  82 ///
  83 /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
  84 /// <value>Loop type of the animated object.</value>
  85     Efl.Gfx.FrameControllerLoopHint LoopType {
  86         get ;
  87     }
  88     /// <summary>Get the number times the animation of the object loops.
  89 /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
  90 ///
  91 /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
  92 /// <value>The number of loop of an animated object.</value>
  93     int LoopCount {
  94         get ;
  95     }
  96 }
  97 /// <summary>Efl frame controller of frame based animated object interface.</summary>
  98 sealed public class IFrameControllerConcrete :
  99
 100 IFrameController
 101
 102 {
 103     ///<summary>Pointer to the native class description.</summary>
 104     public System.IntPtr NativeClass
 105     {
 106         get
 107         {
 108             if (((object)this).GetType() == typeof(IFrameControllerConcrete))
 109             {
 110                 return GetEflClassStatic();
 111             }
 112             else
 113             {
 114                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 115             }
 116         }
 117     }
 118
 119     private  System.IntPtr handle;
 120     ///<summary>Pointer to the native instance.</summary>
 121     public System.IntPtr NativeHandle
 122     {
 123         get { return handle; }
 124     }
 125
 126     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 127         efl_gfx_frame_controller_interface_get();
 128     /// <summary>Initializes a new instance of the <see cref="IFrameController"/> class.
 129     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 130     private IFrameControllerConcrete(System.IntPtr raw)
 131     {
 132         handle = raw;
 133     }
 134     ///<summary>Destructor.</summary>
 135     ~IFrameControllerConcrete()
 136     {
 137         Dispose(false);
 138     }
 139
 140     ///<summary>Releases the underlying native instance.</summary>
 141     private void Dispose(bool disposing)
 142     {
 143         if (handle != System.IntPtr.Zero)
 144         {
 145             IntPtr h = handle;
 146             handle = IntPtr.Zero;
 147
 148             IntPtr gcHandlePtr = IntPtr.Zero;
 149             if (disposing)
 150             {
 151                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 152             }
 153             else
 154             {
 155                 Monitor.Enter(Efl.All.InitLock);
 156                 if (Efl.All.MainLoopInitialized)
 157                 {
 158                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 159                 }
 160
 161                 Monitor.Exit(Efl.All.InitLock);
 162             }
 163         }
 164
 165     }
 166
 167     ///<summary>Releases the underlying native instance.</summary>
 168     public void Dispose()
 169     {
 170         Dispose(true);
 171         GC.SuppressFinalize(this);
 172     }
 173
 174     /// <summary>Verifies if the given object is equal to this one.</summary>
 175     /// <param name="instance">The object to compare to.</param>
 176     /// <returns>True if both objects point to the same native object.</returns>
 177     public override bool Equals(object instance)
 178     {
 179         var other = instance as Efl.Object;
 180         if (other == null)
 181         {
 182             return false;
 183         }
 184         return this.NativeHandle == other.NativeHandle;
 185     }
 186
 187     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 188     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 189     public override int GetHashCode()
 190     {
 191         return this.NativeHandle.ToInt32();
 192     }
 193
 194     /// <summary>Turns the native pointer into a string representation.</summary>
 195     /// <returns>A string with the type and the native pointer for this object.</returns>
 196     public override String ToString()
 197     {
 198         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 199     }
 200
 201     /// <summary>Check if an object can be animated (has multiple frames).
 202     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 203     /// <returns><c>true</c> if the object is animated</returns>
 204     public bool GetAnimated() {
 205          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(this.NativeHandle);
 206         Eina.Error.RaiseIfUnhandledException();
 207         return _ret_var;
 208  }
 209     /// <summary>Index of the current frame of an animated object.
 210     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 211     /// <returns>The index of current frame.</returns>
 212     public int GetFrame() {
 213          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(this.NativeHandle);
 214         Eina.Error.RaiseIfUnhandledException();
 215         return _ret_var;
 216  }
 217     /// <summary>Set the frame to current frame of an animated object.</summary>
 218     /// <param name="frame_index">The index of current frame.</param>
 219     /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
 220     public bool SetFrame(int frame_index) {
 221                                  var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_set_ptr.Value.Delegate(this.NativeHandle,frame_index);
 222         Eina.Error.RaiseIfUnhandledException();
 223                         return _ret_var;
 224  }
 225     /// <summary>Get the total number of frames of the object, if animated.
 226     /// Returns -1 if not animated.</summary>
 227     /// <returns>The number of frames in the animated object.</returns>
 228     public int GetFrameCount() {
 229          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(this.NativeHandle);
 230         Eina.Error.RaiseIfUnhandledException();
 231         return _ret_var;
 232  }
 233     /// <summary>Get the kind of looping the animated object does.
 234     /// This returns the kind of looping the animated object wants to do.
 235     ///
 236     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 237     ///
 238     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 239     ///
 240     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 241     /// <returns>Loop type of the animated object.</returns>
 242     public Efl.Gfx.FrameControllerLoopHint GetLoopType() {
 243          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(this.NativeHandle);
 244         Eina.Error.RaiseIfUnhandledException();
 245         return _ret_var;
 246  }
 247     /// <summary>Get the number times the animation of the object loops.
 248     /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 249     ///
 250     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 251     /// <returns>The number of loop of an animated object.</returns>
 252     public int GetLoopCount() {
 253          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(this.NativeHandle);
 254         Eina.Error.RaiseIfUnhandledException();
 255         return _ret_var;
 256  }
 257     /// <summary>Get the duration of a sequence of frames.
 258     /// This returns total duration in seconds that the specified sequence of frames should take.
 259     ///
 260     /// If <c>start_frame</c> is 1 and <c>frame_num</c> is 0, this returns the duration of frame 1. If <c>start_frame</c> is 1 and <c>frame_num</c> is 1, this returns the total duration of frame 1 + frame 2.</summary>
 261     /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
 262     /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
 263     /// <returns>Duration in seconds</returns>
 264     public double GetFrameDuration(int start_frame, int frame_num) {
 265                                                          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate(this.NativeHandle,start_frame, frame_num);
 266         Eina.Error.RaiseIfUnhandledException();
 267                                         return _ret_var;
 268  }
 269     /// <summary>Check if an object can be animated (has multiple frames).
 270 /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 271 /// <value><c>true</c> if the object is animated</value>
 272     public bool Animated {
 273         get { return GetAnimated(); }
 274     }
 275     /// <summary>Index of the current frame of an animated object.
 276 /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 277 /// <value>The index of current frame.</value>
 278     public int Frame {
 279         get { return GetFrame(); }
 280         set { SetFrame(value); }
 281     }
 282     /// <summary>Get the total number of frames of the object, if animated.
 283 /// Returns -1 if not animated.</summary>
 284 /// <value>The number of frames in the animated object.</value>
 285     public int FrameCount {
 286         get { return GetFrameCount(); }
 287     }
 288     /// <summary>Get the kind of looping the animated object does.
 289 /// This returns the kind of looping the animated object wants to do.
 290 ///
 291 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 292 ///
 293 /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 294 ///
 295 /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 296 /// <value>Loop type of the animated object.</value>
 297     public Efl.Gfx.FrameControllerLoopHint LoopType {
 298         get { return GetLoopType(); }
 299     }
 300     /// <summary>Get the number times the animation of the object loops.
 301 /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 302 ///
 303 /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 304 /// <value>The number of loop of an animated object.</value>
 305     public int LoopCount {
 306         get { return GetLoopCount(); }
 307     }
 308     private static IntPtr GetEflClassStatic()
 309     {
 310         return Efl.Gfx.IFrameControllerConcrete.efl_gfx_frame_controller_interface_get();
 311     }
 312     /// <summary>Wrapper for native methods and virtual method delegates.
 313     /// For internal use by generated code only.</summary>
 314     public class NativeMethods  : Efl.Eo.NativeClass
 315     {
 316         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 317         /// <summary>Gets the list of Eo operations to override.</summary>
 318         /// <returns>The list of Eo operations to be overload.</returns>
 319         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 320         {
 321             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 322             var methods = Efl.Eo.Globals.GetUserMethods(type);
 323
 324             if (efl_gfx_frame_controller_animated_get_static_delegate == null)
 325             {
 326                 efl_gfx_frame_controller_animated_get_static_delegate = new efl_gfx_frame_controller_animated_get_delegate(animated_get);
 327             }
 328
 329             if (methods.FirstOrDefault(m => m.Name == "GetAnimated") != null)
 330             {
 331                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_animated_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_animated_get_static_delegate) });
 332             }
 333
 334             if (efl_gfx_frame_controller_frame_get_static_delegate == null)
 335             {
 336                 efl_gfx_frame_controller_frame_get_static_delegate = new efl_gfx_frame_controller_frame_get_delegate(frame_get);
 337             }
 338
 339             if (methods.FirstOrDefault(m => m.Name == "GetFrame") != null)
 340             {
 341                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_get_static_delegate) });
 342             }
 343
 344             if (efl_gfx_frame_controller_frame_set_static_delegate == null)
 345             {
 346                 efl_gfx_frame_controller_frame_set_static_delegate = new efl_gfx_frame_controller_frame_set_delegate(frame_set);
 347             }
 348
 349             if (methods.FirstOrDefault(m => m.Name == "SetFrame") != null)
 350             {
 351                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_set_static_delegate) });
 352             }
 353
 354             if (efl_gfx_frame_controller_frame_count_get_static_delegate == null)
 355             {
 356                 efl_gfx_frame_controller_frame_count_get_static_delegate = new efl_gfx_frame_controller_frame_count_get_delegate(frame_count_get);
 357             }
 358
 359             if (methods.FirstOrDefault(m => m.Name == "GetFrameCount") != null)
 360             {
 361                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_count_get_static_delegate) });
 362             }
 363
 364             if (efl_gfx_frame_controller_loop_type_get_static_delegate == null)
 365             {
 366                 efl_gfx_frame_controller_loop_type_get_static_delegate = new efl_gfx_frame_controller_loop_type_get_delegate(loop_type_get);
 367             }
 368
 369             if (methods.FirstOrDefault(m => m.Name == "GetLoopType") != null)
 370             {
 371                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_type_get_static_delegate) });
 372             }
 373
 374             if (efl_gfx_frame_controller_loop_count_get_static_delegate == null)
 375             {
 376                 efl_gfx_frame_controller_loop_count_get_static_delegate = new efl_gfx_frame_controller_loop_count_get_delegate(loop_count_get);
 377             }
 378
 379             if (methods.FirstOrDefault(m => m.Name == "GetLoopCount") != null)
 380             {
 381                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_count_get_static_delegate) });
 382             }
 383
 384             if (efl_gfx_frame_controller_frame_duration_get_static_delegate == null)
 385             {
 386                 efl_gfx_frame_controller_frame_duration_get_static_delegate = new efl_gfx_frame_controller_frame_duration_get_delegate(frame_duration_get);
 387             }
 388
 389             if (methods.FirstOrDefault(m => m.Name == "GetFrameDuration") != null)
 390             {
 391                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_duration_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_duration_get_static_delegate) });
 392             }
 393
 394             return descs;
 395         }
 396         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 397         /// <returns>The native class pointer.</returns>
 398         public override IntPtr GetEflClass()
 399         {
 400             return Efl.Gfx.IFrameControllerConcrete.efl_gfx_frame_controller_interface_get();
 401         }
 402
 403         #pragma warning disable CA1707, SA1300, SA1600
 404
 405         [return: MarshalAs(UnmanagedType.U1)]
 406         private delegate bool efl_gfx_frame_controller_animated_get_delegate(System.IntPtr obj, System.IntPtr pd);
 407
 408         [return: MarshalAs(UnmanagedType.U1)]
 409         public delegate bool efl_gfx_frame_controller_animated_get_api_delegate(System.IntPtr obj);
 410
 411         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate> efl_gfx_frame_controller_animated_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate>(Module, "efl_gfx_frame_controller_animated_get");
 412
 413         private static bool animated_get(System.IntPtr obj, System.IntPtr pd)
 414         {
 415             Eina.Log.Debug("function efl_gfx_frame_controller_animated_get was called");
 416             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 417             if (wrapper != null)
 418             {
 419             bool _ret_var = default(bool);
 420                 try
 421                 {
 422                     _ret_var = ((IFrameController)wrapper).GetAnimated();
 423                 }
 424                 catch (Exception e)
 425                 {
 426                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 427                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 428                 }
 429
 430         return _ret_var;
 431
 432             }
 433             else
 434             {
 435                 return efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 436             }
 437         }
 438
 439         private static efl_gfx_frame_controller_animated_get_delegate efl_gfx_frame_controller_animated_get_static_delegate;
 440
 441
 442         private delegate int efl_gfx_frame_controller_frame_get_delegate(System.IntPtr obj, System.IntPtr pd);
 443
 444
 445         public delegate int efl_gfx_frame_controller_frame_get_api_delegate(System.IntPtr obj);
 446
 447         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate> efl_gfx_frame_controller_frame_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_get");
 448
 449         private static int frame_get(System.IntPtr obj, System.IntPtr pd)
 450         {
 451             Eina.Log.Debug("function efl_gfx_frame_controller_frame_get was called");
 452             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 453             if (wrapper != null)
 454             {
 455             int _ret_var = default(int);
 456                 try
 457                 {
 458                     _ret_var = ((IFrameController)wrapper).GetFrame();
 459                 }
 460                 catch (Exception e)
 461                 {
 462                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 463                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 464                 }
 465
 466         return _ret_var;
 467
 468             }
 469             else
 470             {
 471                 return efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 472             }
 473         }
 474
 475         private static efl_gfx_frame_controller_frame_get_delegate efl_gfx_frame_controller_frame_get_static_delegate;
 476
 477         [return: MarshalAs(UnmanagedType.U1)]
 478         private delegate bool efl_gfx_frame_controller_frame_set_delegate(System.IntPtr obj, System.IntPtr pd,  int frame_index);
 479
 480         [return: MarshalAs(UnmanagedType.U1)]
 481         public delegate bool efl_gfx_frame_controller_frame_set_api_delegate(System.IntPtr obj,  int frame_index);
 482
 483         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate> efl_gfx_frame_controller_frame_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate>(Module, "efl_gfx_frame_controller_frame_set");
 484
 485         private static bool frame_set(System.IntPtr obj, System.IntPtr pd, int frame_index)
 486         {
 487             Eina.Log.Debug("function efl_gfx_frame_controller_frame_set was called");
 488             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 489             if (wrapper != null)
 490             {
 491                                     bool _ret_var = default(bool);
 492                 try
 493                 {
 494                     _ret_var = ((IFrameController)wrapper).SetFrame(frame_index);
 495                 }
 496                 catch (Exception e)
 497                 {
 498                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 499                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 500                 }
 501
 502                         return _ret_var;
 503
 504             }
 505             else
 506             {
 507                 return efl_gfx_frame_controller_frame_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), frame_index);
 508             }
 509         }
 510
 511         private static efl_gfx_frame_controller_frame_set_delegate efl_gfx_frame_controller_frame_set_static_delegate;
 512
 513
 514         private delegate int efl_gfx_frame_controller_frame_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 515
 516
 517         public delegate int efl_gfx_frame_controller_frame_count_get_api_delegate(System.IntPtr obj);
 518
 519         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate> efl_gfx_frame_controller_frame_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_count_get");
 520
 521         private static int frame_count_get(System.IntPtr obj, System.IntPtr pd)
 522         {
 523             Eina.Log.Debug("function efl_gfx_frame_controller_frame_count_get was called");
 524             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 525             if (wrapper != null)
 526             {
 527             int _ret_var = default(int);
 528                 try
 529                 {
 530                     _ret_var = ((IFrameController)wrapper).GetFrameCount();
 531                 }
 532                 catch (Exception e)
 533                 {
 534                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 535                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 536                 }
 537
 538         return _ret_var;
 539
 540             }
 541             else
 542             {
 543                 return efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 544             }
 545         }
 546
 547         private static efl_gfx_frame_controller_frame_count_get_delegate efl_gfx_frame_controller_frame_count_get_static_delegate;
 548
 549
 550         private delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 551
 552
 553         public delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_api_delegate(System.IntPtr obj);
 554
 555         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate> efl_gfx_frame_controller_loop_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_type_get");
 556
 557         private static Efl.Gfx.FrameControllerLoopHint loop_type_get(System.IntPtr obj, System.IntPtr pd)
 558         {
 559             Eina.Log.Debug("function efl_gfx_frame_controller_loop_type_get was called");
 560             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 561             if (wrapper != null)
 562             {
 563             Efl.Gfx.FrameControllerLoopHint _ret_var = default(Efl.Gfx.FrameControllerLoopHint);
 564                 try
 565                 {
 566                     _ret_var = ((IFrameController)wrapper).GetLoopType();
 567                 }
 568                 catch (Exception e)
 569                 {
 570                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 571                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 572                 }
 573
 574         return _ret_var;
 575
 576             }
 577             else
 578             {
 579                 return efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 580             }
 581         }
 582
 583         private static efl_gfx_frame_controller_loop_type_get_delegate efl_gfx_frame_controller_loop_type_get_static_delegate;
 584
 585
 586         private delegate int efl_gfx_frame_controller_loop_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 587
 588
 589         public delegate int efl_gfx_frame_controller_loop_count_get_api_delegate(System.IntPtr obj);
 590
 591         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate> efl_gfx_frame_controller_loop_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_count_get");
 592
 593         private static int loop_count_get(System.IntPtr obj, System.IntPtr pd)
 594         {
 595             Eina.Log.Debug("function efl_gfx_frame_controller_loop_count_get was called");
 596             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 597             if (wrapper != null)
 598             {
 599             int _ret_var = default(int);
 600                 try
 601                 {
 602                     _ret_var = ((IFrameController)wrapper).GetLoopCount();
 603                 }
 604                 catch (Exception e)
 605                 {
 606                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 607                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 608                 }
 609
 610         return _ret_var;
 611
 612             }
 613             else
 614             {
 615                 return efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 616             }
 617         }
 618
 619         private static efl_gfx_frame_controller_loop_count_get_delegate efl_gfx_frame_controller_loop_count_get_static_delegate;
 620
 621
 622         private delegate double efl_gfx_frame_controller_frame_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,  int start_frame,  int frame_num);
 623
 624
 625         public delegate double efl_gfx_frame_controller_frame_duration_get_api_delegate(System.IntPtr obj,  int start_frame,  int frame_num);
 626
 627         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate> efl_gfx_frame_controller_frame_duration_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_duration_get");
 628
 629         private static double frame_duration_get(System.IntPtr obj, System.IntPtr pd, int start_frame, int frame_num)
 630         {
 631             Eina.Log.Debug("function efl_gfx_frame_controller_frame_duration_get was called");
 632             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 633             if (wrapper != null)
 634             {
 635                                                             double _ret_var = default(double);
 636                 try
 637                 {
 638                     _ret_var = ((IFrameController)wrapper).GetFrameDuration(start_frame, frame_num);
 639                 }
 640                 catch (Exception e)
 641                 {
 642                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 643                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 644                 }
 645
 646                                         return _ret_var;
 647
 648             }
 649             else
 650             {
 651                 return efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start_frame, frame_num);
 652             }
 653         }
 654
 655         private static efl_gfx_frame_controller_frame_duration_get_delegate efl_gfx_frame_controller_frame_duration_get_static_delegate;
 656
 657         #pragma warning restore CA1707, SA1300, SA1600
 658
 659 }
 660 }
 661 }
 662
 663 }
 664
 665 namespace Efl {
 666
 667 namespace Gfx {
 668
 669 /// <summary>Frame loop modes</summary>
 670 public enum FrameControllerLoopHint
 671 {
 672 /// <summary>No looping order specified.</summary>
 673 None = 0,
 674 /// <summary>Standard loop: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1</summary>
 675 Loop = 1,
 676 /// <summary>Ping-pong bouncing loop: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1</summary>
 677 Pingpong = 2,
 678 }
 679
 680 }
 681
 682 }
 683