internals/src/EflSharp/EflSharp/efl/efl_gfx_frame_controller.eo.cs

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