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     Efl.Eo.EoWrapper
 100     , IFrameController
 101
 102 {
 103     ///<summary>Pointer to the native class description.</summary>
 104     public override 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     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 120         efl_gfx_frame_controller_interface_get();
 121     /// <summary>Initializes a new instance of the <see cref="IFrameController"/> class.
 122     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 123     private IFrameControllerConcrete(System.IntPtr raw) : base(raw)
 124     {
 125     }
 126
 127     /// <summary>Check if an object can be animated (has multiple frames).
 128     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 129     /// <returns><c>true</c> if the object is animated</returns>
 130     public bool GetAnimated() {
 131          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(this.NativeHandle);
 132         Eina.Error.RaiseIfUnhandledException();
 133         return _ret_var;
 134  }
 135     /// <summary>Index of the current frame of an animated object.
 136     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 137     /// <returns>The index of current frame.</returns>
 138     public int GetFrame() {
 139          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(this.NativeHandle);
 140         Eina.Error.RaiseIfUnhandledException();
 141         return _ret_var;
 142  }
 143     /// <summary>Set the frame to current frame of an animated object.</summary>
 144     /// <param name="frame_index">The index of current frame.</param>
 145     /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
 146     public bool SetFrame(int frame_index) {
 147                                  var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_set_ptr.Value.Delegate(this.NativeHandle,frame_index);
 148         Eina.Error.RaiseIfUnhandledException();
 149                         return _ret_var;
 150  }
 151     /// <summary>Get the total number of frames of the object, if animated.
 152     /// Returns -1 if not animated.</summary>
 153     /// <returns>The number of frames in the animated object.</returns>
 154     public int GetFrameCount() {
 155          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(this.NativeHandle);
 156         Eina.Error.RaiseIfUnhandledException();
 157         return _ret_var;
 158  }
 159     /// <summary>Get the kind of looping the animated object does.
 160     /// This returns the kind of looping the animated object wants to do.
 161     ///
 162     /// 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...
 163     ///
 164     /// 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...
 165     ///
 166     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 167     /// <returns>Loop type of the animated object.</returns>
 168     public Efl.Gfx.FrameControllerLoopHint GetLoopType() {
 169          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(this.NativeHandle);
 170         Eina.Error.RaiseIfUnhandledException();
 171         return _ret_var;
 172  }
 173     /// <summary>Get the number times the animation of the object loops.
 174     /// 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).
 175     ///
 176     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 177     /// <returns>The number of loop of an animated object.</returns>
 178     public int GetLoopCount() {
 179          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(this.NativeHandle);
 180         Eina.Error.RaiseIfUnhandledException();
 181         return _ret_var;
 182  }
 183     /// <summary>Get the duration of a sequence of frames.
 184     /// This returns total duration in seconds that the specified sequence of frames should take.
 185     ///
 186     /// 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>
 187     /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
 188     /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
 189     /// <returns>Duration in seconds</returns>
 190     public double GetFrameDuration(int start_frame, int frame_num) {
 191                                                          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate(this.NativeHandle,start_frame, frame_num);
 192         Eina.Error.RaiseIfUnhandledException();
 193                                         return _ret_var;
 194  }
 195     /// <summary>Check if an object can be animated (has multiple frames).
 196     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 197     /// <value><c>true</c> if the object is animated</value>
 198     public bool Animated {
 199         get { return GetAnimated(); }
 200     }
 201     /// <summary>Index of the current frame of an animated object.
 202     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 203     /// <value>The index of current frame.</value>
 204     public int Frame {
 205         get { return GetFrame(); }
 206         set { SetFrame(value); }
 207     }
 208     /// <summary>Get the total number of frames of the object, if animated.
 209     /// Returns -1 if not animated.</summary>
 210     /// <value>The number of frames in the animated object.</value>
 211     public int FrameCount {
 212         get { return GetFrameCount(); }
 213     }
 214     /// <summary>Get the kind of looping the animated object does.
 215     /// This returns the kind of looping the animated object wants to do.
 216     ///
 217     /// 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...
 218     ///
 219     /// 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...
 220     ///
 221     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 222     /// <value>Loop type of the animated object.</value>
 223     public Efl.Gfx.FrameControllerLoopHint LoopType {
 224         get { return GetLoopType(); }
 225     }
 226     /// <summary>Get the number times the animation of the object loops.
 227     /// 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).
 228     ///
 229     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 230     /// <value>The number of loop of an animated object.</value>
 231     public int LoopCount {
 232         get { return GetLoopCount(); }
 233     }
 234     private static IntPtr GetEflClassStatic()
 235     {
 236         return Efl.Gfx.IFrameControllerConcrete.efl_gfx_frame_controller_interface_get();
 237     }
 238     /// <summary>Wrapper for native methods and virtual method delegates.
 239     /// For internal use by generated code only.</summary>
 240     public class NativeMethods  : Efl.Eo.NativeClass
 241     {
 242         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 243         /// <summary>Gets the list of Eo operations to override.</summary>
 244         /// <returns>The list of Eo operations to be overload.</returns>
 245         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 246         {
 247             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 248             var methods = Efl.Eo.Globals.GetUserMethods(type);
 249
 250             if (efl_gfx_frame_controller_animated_get_static_delegate == null)
 251             {
 252                 efl_gfx_frame_controller_animated_get_static_delegate = new efl_gfx_frame_controller_animated_get_delegate(animated_get);
 253             }
 254
 255             if (methods.FirstOrDefault(m => m.Name == "GetAnimated") != null)
 256             {
 257                 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) });
 258             }
 259
 260             if (efl_gfx_frame_controller_frame_get_static_delegate == null)
 261             {
 262                 efl_gfx_frame_controller_frame_get_static_delegate = new efl_gfx_frame_controller_frame_get_delegate(frame_get);
 263             }
 264
 265             if (methods.FirstOrDefault(m => m.Name == "GetFrame") != null)
 266             {
 267                 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) });
 268             }
 269
 270             if (efl_gfx_frame_controller_frame_set_static_delegate == null)
 271             {
 272                 efl_gfx_frame_controller_frame_set_static_delegate = new efl_gfx_frame_controller_frame_set_delegate(frame_set);
 273             }
 274
 275             if (methods.FirstOrDefault(m => m.Name == "SetFrame") != null)
 276             {
 277                 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) });
 278             }
 279
 280             if (efl_gfx_frame_controller_frame_count_get_static_delegate == null)
 281             {
 282                 efl_gfx_frame_controller_frame_count_get_static_delegate = new efl_gfx_frame_controller_frame_count_get_delegate(frame_count_get);
 283             }
 284
 285             if (methods.FirstOrDefault(m => m.Name == "GetFrameCount") != null)
 286             {
 287                 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) });
 288             }
 289
 290             if (efl_gfx_frame_controller_loop_type_get_static_delegate == null)
 291             {
 292                 efl_gfx_frame_controller_loop_type_get_static_delegate = new efl_gfx_frame_controller_loop_type_get_delegate(loop_type_get);
 293             }
 294
 295             if (methods.FirstOrDefault(m => m.Name == "GetLoopType") != null)
 296             {
 297                 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) });
 298             }
 299
 300             if (efl_gfx_frame_controller_loop_count_get_static_delegate == null)
 301             {
 302                 efl_gfx_frame_controller_loop_count_get_static_delegate = new efl_gfx_frame_controller_loop_count_get_delegate(loop_count_get);
 303             }
 304
 305             if (methods.FirstOrDefault(m => m.Name == "GetLoopCount") != null)
 306             {
 307                 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) });
 308             }
 309
 310             if (efl_gfx_frame_controller_frame_duration_get_static_delegate == null)
 311             {
 312                 efl_gfx_frame_controller_frame_duration_get_static_delegate = new efl_gfx_frame_controller_frame_duration_get_delegate(frame_duration_get);
 313             }
 314
 315             if (methods.FirstOrDefault(m => m.Name == "GetFrameDuration") != null)
 316             {
 317                 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) });
 318             }
 319
 320             return descs;
 321         }
 322         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 323         /// <returns>The native class pointer.</returns>
 324         public override IntPtr GetEflClass()
 325         {
 326             return Efl.Gfx.IFrameControllerConcrete.efl_gfx_frame_controller_interface_get();
 327         }
 328
 329         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 330
 331         [return: MarshalAs(UnmanagedType.U1)]
 332         private delegate bool efl_gfx_frame_controller_animated_get_delegate(System.IntPtr obj, System.IntPtr pd);
 333
 334         [return: MarshalAs(UnmanagedType.U1)]
 335         public delegate bool efl_gfx_frame_controller_animated_get_api_delegate(System.IntPtr obj);
 336
 337         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");
 338
 339         private static bool animated_get(System.IntPtr obj, System.IntPtr pd)
 340         {
 341             Eina.Log.Debug("function efl_gfx_frame_controller_animated_get was called");
 342             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 343             if (ws != null)
 344             {
 345             bool _ret_var = default(bool);
 346                 try
 347                 {
 348                     _ret_var = ((IFrameController)ws.Target).GetAnimated();
 349                 }
 350                 catch (Exception e)
 351                 {
 352                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 353                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 354                 }
 355
 356         return _ret_var;
 357
 358             }
 359             else
 360             {
 361                 return efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 362             }
 363         }
 364
 365         private static efl_gfx_frame_controller_animated_get_delegate efl_gfx_frame_controller_animated_get_static_delegate;
 366
 367
 368         private delegate int efl_gfx_frame_controller_frame_get_delegate(System.IntPtr obj, System.IntPtr pd);
 369
 370
 371         public delegate int efl_gfx_frame_controller_frame_get_api_delegate(System.IntPtr obj);
 372
 373         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");
 374
 375         private static int frame_get(System.IntPtr obj, System.IntPtr pd)
 376         {
 377             Eina.Log.Debug("function efl_gfx_frame_controller_frame_get was called");
 378             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 379             if (ws != null)
 380             {
 381             int _ret_var = default(int);
 382                 try
 383                 {
 384                     _ret_var = ((IFrameController)ws.Target).GetFrame();
 385                 }
 386                 catch (Exception e)
 387                 {
 388                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 389                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 390                 }
 391
 392         return _ret_var;
 393
 394             }
 395             else
 396             {
 397                 return efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 398             }
 399         }
 400
 401         private static efl_gfx_frame_controller_frame_get_delegate efl_gfx_frame_controller_frame_get_static_delegate;
 402
 403         [return: MarshalAs(UnmanagedType.U1)]
 404         private delegate bool efl_gfx_frame_controller_frame_set_delegate(System.IntPtr obj, System.IntPtr pd,  int frame_index);
 405
 406         [return: MarshalAs(UnmanagedType.U1)]
 407         public delegate bool efl_gfx_frame_controller_frame_set_api_delegate(System.IntPtr obj,  int frame_index);
 408
 409         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");
 410
 411         private static bool frame_set(System.IntPtr obj, System.IntPtr pd, int frame_index)
 412         {
 413             Eina.Log.Debug("function efl_gfx_frame_controller_frame_set was called");
 414             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 415             if (ws != null)
 416             {
 417                                     bool _ret_var = default(bool);
 418                 try
 419                 {
 420                     _ret_var = ((IFrameController)ws.Target).SetFrame(frame_index);
 421                 }
 422                 catch (Exception e)
 423                 {
 424                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 425                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 426                 }
 427
 428                         return _ret_var;
 429
 430             }
 431             else
 432             {
 433                 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);
 434             }
 435         }
 436
 437         private static efl_gfx_frame_controller_frame_set_delegate efl_gfx_frame_controller_frame_set_static_delegate;
 438
 439
 440         private delegate int efl_gfx_frame_controller_frame_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 441
 442
 443         public delegate int efl_gfx_frame_controller_frame_count_get_api_delegate(System.IntPtr obj);
 444
 445         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");
 446
 447         private static int frame_count_get(System.IntPtr obj, System.IntPtr pd)
 448         {
 449             Eina.Log.Debug("function efl_gfx_frame_controller_frame_count_get was called");
 450             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 451             if (ws != null)
 452             {
 453             int _ret_var = default(int);
 454                 try
 455                 {
 456                     _ret_var = ((IFrameController)ws.Target).GetFrameCount();
 457                 }
 458                 catch (Exception e)
 459                 {
 460                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 461                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 462                 }
 463
 464         return _ret_var;
 465
 466             }
 467             else
 468             {
 469                 return efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 470             }
 471         }
 472
 473         private static efl_gfx_frame_controller_frame_count_get_delegate efl_gfx_frame_controller_frame_count_get_static_delegate;
 474
 475
 476         private delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 477
 478
 479         public delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_api_delegate(System.IntPtr obj);
 480
 481         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");
 482
 483         private static Efl.Gfx.FrameControllerLoopHint loop_type_get(System.IntPtr obj, System.IntPtr pd)
 484         {
 485             Eina.Log.Debug("function efl_gfx_frame_controller_loop_type_get was called");
 486             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 487             if (ws != null)
 488             {
 489             Efl.Gfx.FrameControllerLoopHint _ret_var = default(Efl.Gfx.FrameControllerLoopHint);
 490                 try
 491                 {
 492                     _ret_var = ((IFrameController)ws.Target).GetLoopType();
 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_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 506             }
 507         }
 508
 509         private static efl_gfx_frame_controller_loop_type_get_delegate efl_gfx_frame_controller_loop_type_get_static_delegate;
 510
 511
 512         private delegate int efl_gfx_frame_controller_loop_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 513
 514
 515         public delegate int efl_gfx_frame_controller_loop_count_get_api_delegate(System.IntPtr obj);
 516
 517         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");
 518
 519         private static int loop_count_get(System.IntPtr obj, System.IntPtr pd)
 520         {
 521             Eina.Log.Debug("function efl_gfx_frame_controller_loop_count_get was called");
 522             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 523             if (ws != null)
 524             {
 525             int _ret_var = default(int);
 526                 try
 527                 {
 528                     _ret_var = ((IFrameController)ws.Target).GetLoopCount();
 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         return _ret_var;
 537
 538             }
 539             else
 540             {
 541                 return efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 542             }
 543         }
 544
 545         private static efl_gfx_frame_controller_loop_count_get_delegate efl_gfx_frame_controller_loop_count_get_static_delegate;
 546
 547
 548         private delegate double efl_gfx_frame_controller_frame_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,  int start_frame,  int frame_num);
 549
 550
 551         public delegate double efl_gfx_frame_controller_frame_duration_get_api_delegate(System.IntPtr obj,  int start_frame,  int frame_num);
 552
 553         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");
 554
 555         private static double frame_duration_get(System.IntPtr obj, System.IntPtr pd, int start_frame, int frame_num)
 556         {
 557             Eina.Log.Debug("function efl_gfx_frame_controller_frame_duration_get was called");
 558             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 559             if (ws != null)
 560             {
 561                                                             double _ret_var = default(double);
 562                 try
 563                 {
 564                     _ret_var = ((IFrameController)ws.Target).GetFrameDuration(start_frame, frame_num);
 565                 }
 566                 catch (Exception e)
 567                 {
 568                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 569                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 570                 }
 571
 572                                         return _ret_var;
 573
 574             }
 575             else
 576             {
 577                 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);
 578             }
 579         }
 580
 581         private static efl_gfx_frame_controller_frame_duration_get_delegate efl_gfx_frame_controller_frame_duration_get_static_delegate;
 582
 583         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 584
 585 }
 586 }
 587 }
 588
 589 }
 590
 591 namespace Efl {
 592
 593 namespace Gfx {
 594
 595 /// <summary>Frame loop modes</summary>
 596 public enum FrameControllerLoopHint
 597 {
 598 /// <summary>No looping order specified.</summary>
 599 None = 0,
 600 /// <summary>Standard loop: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1</summary>
 601 Loop = 1,
 602 /// <summary>Ping-pong bouncing loop: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1</summary>
 603 Pingpong = 2,
 604 }
 605
 606 }
 607
 608 }
 609