internals/src/EflSharp/EflSharp/efl/efl_player.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 /// <summary>Efl media player interface</summary>
  11 [Efl.IPlayerConcrete.NativeMethods]
  12 public interface IPlayer :
  13     Efl.Eo.IWrapper, IDisposable
  14 {
  15     /// <summary>Whether or not the playable can be played.</summary>
  16 /// <returns><c>true</c> if the object have playable data, <c>false</c> otherwise</returns>
  17 bool GetPlayable();
  18     /// <summary>Get play/pause state of the media file.</summary>
  19 /// <returns><c>true</c> if playing, <c>false</c> otherwise.</returns>
  20 bool GetPlay();
  21     /// <summary>Set play/pause state of the media file.
  22 /// This functions sets the currently playing status of the video. Using this function to play or pause the video doesn&apos;t alter it&apos;s current position.</summary>
  23 /// <param name="play"><c>true</c> if playing, <c>false</c> otherwise.</param>
  24 void SetPlay(bool play);
  25     /// <summary>Get the position in the media file.
  26 /// The position is returned as the number of seconds since the beginning of the media file.</summary>
  27 /// <returns>The position (in seconds).</returns>
  28 double GetPos();
  29     /// <summary>Set the position in the media file.
  30 /// This functions sets the current position of the media file to &quot;sec&quot;, this only works on seekable streams. Setting the position doesn&apos;t change the playing state of the media file.</summary>
  31 /// <param name="sec">The position (in seconds).</param>
  32 void SetPos(double sec);
  33     /// <summary>Get how much of the file has been played.
  34 /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
  35 /// <returns>The progress within the [0, 1] range.</returns>
  36 double GetProgress();
  37     /// <summary>Control the play speed of the media file.
  38 /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
  39 /// <returns>The play speed in the [0, infinity) range.</returns>
  40 double GetPlaySpeed();
  41     /// <summary>Control the play speed of the media file.
  42 /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
  43 /// <param name="speed">The play speed in the [0, infinity) range.</param>
  44 void SetPlaySpeed(double speed);
  45     /// <summary>Control the audio volume.
  46 /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
  47 /// <returns>The volume level</returns>
  48 double GetVolume();
  49     /// <summary>Control the audio volume.
  50 /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
  51 /// <param name="volume">The volume level</param>
  52 void SetVolume(double volume);
  53     /// <summary>This property controls the audio mute state.</summary>
  54 /// <returns>The mute state. <c>true</c> or <c>false</c>.</returns>
  55 bool GetMute();
  56     /// <summary>This property controls the audio mute state.</summary>
  57 /// <param name="mute">The mute state. <c>true</c> or <c>false</c>.</param>
  58 void SetMute(bool mute);
  59     /// <summary>Get the length of play for the media file.</summary>
  60 /// <returns>The length of the stream in seconds.</returns>
  61 double GetLength();
  62     /// <summary>Get whether the media file is seekable.</summary>
  63 /// <returns><c>true</c> if seekable.</returns>
  64 bool GetSeekable();
  65     /// <summary>Start a playing playable object.</summary>
  66 void Start();
  67     /// <summary>Stop playable object.</summary>
  68 void Stop();
  69                                                                     /// <summary>Whether or not the playable can be played.</summary>
  70 /// <value><c>true</c> if the object have playable data, <c>false</c> otherwise</value>
  71     bool Playable {
  72         get ;
  73     }
  74     /// <summary>Get play/pause state of the media file.</summary>
  75 /// <value><c>true</c> if playing, <c>false</c> otherwise.</value>
  76     bool Play {
  77         get ;
  78         set ;
  79     }
  80     /// <summary>Get the position in the media file.
  81 /// The position is returned as the number of seconds since the beginning of the media file.</summary>
  82 /// <value>The position (in seconds).</value>
  83     double Pos {
  84         get ;
  85         set ;
  86     }
  87     /// <summary>Get how much of the file has been played.
  88 /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
  89 /// <value>The progress within the [0, 1] range.</value>
  90     double Progress {
  91         get ;
  92     }
  93     /// <summary>Control the play speed of the media file.
  94 /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
  95 /// <value>The play speed in the [0, infinity) range.</value>
  96     double PlaySpeed {
  97         get ;
  98         set ;
  99     }
 100     /// <summary>Control the audio volume.
 101 /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 102 /// <value>The volume level</value>
 103     double Volume {
 104         get ;
 105         set ;
 106     }
 107     /// <summary>This property controls the audio mute state.</summary>
 108 /// <value>The mute state. <c>true</c> or <c>false</c>.</value>
 109     bool Mute {
 110         get ;
 111         set ;
 112     }
 113     /// <summary>Get the length of play for the media file.</summary>
 114 /// <value>The length of the stream in seconds.</value>
 115     double Length {
 116         get ;
 117     }
 118     /// <summary>Get whether the media file is seekable.</summary>
 119 /// <value><c>true</c> if seekable.</value>
 120     bool Seekable {
 121         get ;
 122     }
 123 }
 124 /// <summary>Efl media player interface</summary>
 125 sealed public class IPlayerConcrete :
 126
 127 IPlayer
 128
 129 {
 130     ///<summary>Pointer to the native class description.</summary>
 131     public System.IntPtr NativeClass
 132     {
 133         get
 134         {
 135             if (((object)this).GetType() == typeof(IPlayerConcrete))
 136             {
 137                 return GetEflClassStatic();
 138             }
 139             else
 140             {
 141                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 142             }
 143         }
 144     }
 145
 146     private  System.IntPtr handle;
 147     ///<summary>Pointer to the native instance.</summary>
 148     public System.IntPtr NativeHandle
 149     {
 150         get { return handle; }
 151     }
 152
 153     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 154         efl_player_interface_get();
 155     /// <summary>Initializes a new instance of the <see cref="IPlayer"/> class.
 156     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 157     private IPlayerConcrete(System.IntPtr raw)
 158     {
 159         handle = raw;
 160     }
 161     ///<summary>Destructor.</summary>
 162     ~IPlayerConcrete()
 163     {
 164         Dispose(false);
 165     }
 166
 167     ///<summary>Releases the underlying native instance.</summary>
 168     private void Dispose(bool disposing)
 169     {
 170         if (handle != System.IntPtr.Zero)
 171         {
 172             IntPtr h = handle;
 173             handle = IntPtr.Zero;
 174
 175             IntPtr gcHandlePtr = IntPtr.Zero;
 176             if (disposing)
 177             {
 178                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 179             }
 180             else
 181             {
 182                 Monitor.Enter(Efl.All.InitLock);
 183                 if (Efl.All.MainLoopInitialized)
 184                 {
 185                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 186                 }
 187
 188                 Monitor.Exit(Efl.All.InitLock);
 189             }
 190         }
 191
 192     }
 193
 194     ///<summary>Releases the underlying native instance.</summary>
 195     public void Dispose()
 196     {
 197         Dispose(true);
 198         GC.SuppressFinalize(this);
 199     }
 200
 201     /// <summary>Verifies if the given object is equal to this one.</summary>
 202     /// <param name="instance">The object to compare to.</param>
 203     /// <returns>True if both objects point to the same native object.</returns>
 204     public override bool Equals(object instance)
 205     {
 206         var other = instance as Efl.Object;
 207         if (other == null)
 208         {
 209             return false;
 210         }
 211         return this.NativeHandle == other.NativeHandle;
 212     }
 213
 214     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 215     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 216     public override int GetHashCode()
 217     {
 218         return this.NativeHandle.ToInt32();
 219     }
 220
 221     /// <summary>Turns the native pointer into a string representation.</summary>
 222     /// <returns>A string with the type and the native pointer for this object.</returns>
 223     public override String ToString()
 224     {
 225         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 226     }
 227
 228     /// <summary>Whether or not the playable can be played.</summary>
 229     /// <returns><c>true</c> if the object have playable data, <c>false</c> otherwise</returns>
 230     public bool GetPlayable() {
 231          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_playable_get_ptr.Value.Delegate(this.NativeHandle);
 232         Eina.Error.RaiseIfUnhandledException();
 233         return _ret_var;
 234  }
 235     /// <summary>Get play/pause state of the media file.</summary>
 236     /// <returns><c>true</c> if playing, <c>false</c> otherwise.</returns>
 237     public bool GetPlay() {
 238          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_play_get_ptr.Value.Delegate(this.NativeHandle);
 239         Eina.Error.RaiseIfUnhandledException();
 240         return _ret_var;
 241  }
 242     /// <summary>Set play/pause state of the media file.
 243     /// This functions sets the currently playing status of the video. Using this function to play or pause the video doesn&apos;t alter it&apos;s current position.</summary>
 244     /// <param name="play"><c>true</c> if playing, <c>false</c> otherwise.</param>
 245     public void SetPlay(bool play) {
 246                                  Efl.IPlayerConcrete.NativeMethods.efl_player_play_set_ptr.Value.Delegate(this.NativeHandle,play);
 247         Eina.Error.RaiseIfUnhandledException();
 248                          }
 249     /// <summary>Get the position in the media file.
 250     /// The position is returned as the number of seconds since the beginning of the media file.</summary>
 251     /// <returns>The position (in seconds).</returns>
 252     public double GetPos() {
 253          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_pos_get_ptr.Value.Delegate(this.NativeHandle);
 254         Eina.Error.RaiseIfUnhandledException();
 255         return _ret_var;
 256  }
 257     /// <summary>Set the position in the media file.
 258     /// This functions sets the current position of the media file to &quot;sec&quot;, this only works on seekable streams. Setting the position doesn&apos;t change the playing state of the media file.</summary>
 259     /// <param name="sec">The position (in seconds).</param>
 260     public void SetPos(double sec) {
 261                                  Efl.IPlayerConcrete.NativeMethods.efl_player_pos_set_ptr.Value.Delegate(this.NativeHandle,sec);
 262         Eina.Error.RaiseIfUnhandledException();
 263                          }
 264     /// <summary>Get how much of the file has been played.
 265     /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
 266     /// <returns>The progress within the [0, 1] range.</returns>
 267     public double GetProgress() {
 268          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_progress_get_ptr.Value.Delegate(this.NativeHandle);
 269         Eina.Error.RaiseIfUnhandledException();
 270         return _ret_var;
 271  }
 272     /// <summary>Control the play speed of the media file.
 273     /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
 274     /// <returns>The play speed in the [0, infinity) range.</returns>
 275     public double GetPlaySpeed() {
 276          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_play_speed_get_ptr.Value.Delegate(this.NativeHandle);
 277         Eina.Error.RaiseIfUnhandledException();
 278         return _ret_var;
 279  }
 280     /// <summary>Control the play speed of the media file.
 281     /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
 282     /// <param name="speed">The play speed in the [0, infinity) range.</param>
 283     public void SetPlaySpeed(double speed) {
 284                                  Efl.IPlayerConcrete.NativeMethods.efl_player_play_speed_set_ptr.Value.Delegate(this.NativeHandle,speed);
 285         Eina.Error.RaiseIfUnhandledException();
 286                          }
 287     /// <summary>Control the audio volume.
 288     /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 289     /// <returns>The volume level</returns>
 290     public double GetVolume() {
 291          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_volume_get_ptr.Value.Delegate(this.NativeHandle);
 292         Eina.Error.RaiseIfUnhandledException();
 293         return _ret_var;
 294  }
 295     /// <summary>Control the audio volume.
 296     /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 297     /// <param name="volume">The volume level</param>
 298     public void SetVolume(double volume) {
 299                                  Efl.IPlayerConcrete.NativeMethods.efl_player_volume_set_ptr.Value.Delegate(this.NativeHandle,volume);
 300         Eina.Error.RaiseIfUnhandledException();
 301                          }
 302     /// <summary>This property controls the audio mute state.</summary>
 303     /// <returns>The mute state. <c>true</c> or <c>false</c>.</returns>
 304     public bool GetMute() {
 305          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_mute_get_ptr.Value.Delegate(this.NativeHandle);
 306         Eina.Error.RaiseIfUnhandledException();
 307         return _ret_var;
 308  }
 309     /// <summary>This property controls the audio mute state.</summary>
 310     /// <param name="mute">The mute state. <c>true</c> or <c>false</c>.</param>
 311     public void SetMute(bool mute) {
 312                                  Efl.IPlayerConcrete.NativeMethods.efl_player_mute_set_ptr.Value.Delegate(this.NativeHandle,mute);
 313         Eina.Error.RaiseIfUnhandledException();
 314                          }
 315     /// <summary>Get the length of play for the media file.</summary>
 316     /// <returns>The length of the stream in seconds.</returns>
 317     public double GetLength() {
 318          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_length_get_ptr.Value.Delegate(this.NativeHandle);
 319         Eina.Error.RaiseIfUnhandledException();
 320         return _ret_var;
 321  }
 322     /// <summary>Get whether the media file is seekable.</summary>
 323     /// <returns><c>true</c> if seekable.</returns>
 324     public bool GetSeekable() {
 325          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_seekable_get_ptr.Value.Delegate(this.NativeHandle);
 326         Eina.Error.RaiseIfUnhandledException();
 327         return _ret_var;
 328  }
 329     /// <summary>Start a playing playable object.</summary>
 330     public void Start() {
 331          Efl.IPlayerConcrete.NativeMethods.efl_player_start_ptr.Value.Delegate(this.NativeHandle);
 332         Eina.Error.RaiseIfUnhandledException();
 333          }
 334     /// <summary>Stop playable object.</summary>
 335     public void Stop() {
 336          Efl.IPlayerConcrete.NativeMethods.efl_player_stop_ptr.Value.Delegate(this.NativeHandle);
 337         Eina.Error.RaiseIfUnhandledException();
 338          }
 339     /// <summary>Whether or not the playable can be played.</summary>
 340 /// <value><c>true</c> if the object have playable data, <c>false</c> otherwise</value>
 341     public bool Playable {
 342         get { return GetPlayable(); }
 343     }
 344     /// <summary>Get play/pause state of the media file.</summary>
 345 /// <value><c>true</c> if playing, <c>false</c> otherwise.</value>
 346     public bool Play {
 347         get { return GetPlay(); }
 348         set { SetPlay(value); }
 349     }
 350     /// <summary>Get the position in the media file.
 351 /// The position is returned as the number of seconds since the beginning of the media file.</summary>
 352 /// <value>The position (in seconds).</value>
 353     public double Pos {
 354         get { return GetPos(); }
 355         set { SetPos(value); }
 356     }
 357     /// <summary>Get how much of the file has been played.
 358 /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
 359 /// <value>The progress within the [0, 1] range.</value>
 360     public double Progress {
 361         get { return GetProgress(); }
 362     }
 363     /// <summary>Control the play speed of the media file.
 364 /// This function control the speed with which the media file will be played. 1.0 represents the normal speed, 2 double speed, 0.5 half speed and so on.</summary>
 365 /// <value>The play speed in the [0, infinity) range.</value>
 366     public double PlaySpeed {
 367         get { return GetPlaySpeed(); }
 368         set { SetPlaySpeed(value); }
 369     }
 370     /// <summary>Control the audio volume.
 371 /// Controls the audio volume of the stream being played. This has nothing to do with the system volume. This volume will be multiplied by the system volume. e.g.: if the current volume level is 0.5, and the system volume is 50%, it will be 0.5 * 0.5 = 0.25.</summary>
 372 /// <value>The volume level</value>
 373     public double Volume {
 374         get { return GetVolume(); }
 375         set { SetVolume(value); }
 376     }
 377     /// <summary>This property controls the audio mute state.</summary>
 378 /// <value>The mute state. <c>true</c> or <c>false</c>.</value>
 379     public bool Mute {
 380         get { return GetMute(); }
 381         set { SetMute(value); }
 382     }
 383     /// <summary>Get the length of play for the media file.</summary>
 384 /// <value>The length of the stream in seconds.</value>
 385     public double Length {
 386         get { return GetLength(); }
 387     }
 388     /// <summary>Get whether the media file is seekable.</summary>
 389 /// <value><c>true</c> if seekable.</value>
 390     public bool Seekable {
 391         get { return GetSeekable(); }
 392     }
 393     private static IntPtr GetEflClassStatic()
 394     {
 395         return Efl.IPlayerConcrete.efl_player_interface_get();
 396     }
 397     /// <summary>Wrapper for native methods and virtual method delegates.
 398     /// For internal use by generated code only.</summary>
 399     public class NativeMethods  : Efl.Eo.NativeClass
 400     {
 401         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 402         /// <summary>Gets the list of Eo operations to override.</summary>
 403         /// <returns>The list of Eo operations to be overload.</returns>
 404         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 405         {
 406             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 407             var methods = Efl.Eo.Globals.GetUserMethods(type);
 408
 409             if (efl_player_playable_get_static_delegate == null)
 410             {
 411                 efl_player_playable_get_static_delegate = new efl_player_playable_get_delegate(playable_get);
 412             }
 413
 414             if (methods.FirstOrDefault(m => m.Name == "GetPlayable") != null)
 415             {
 416                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_playable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_playable_get_static_delegate) });
 417             }
 418
 419             if (efl_player_play_get_static_delegate == null)
 420             {
 421                 efl_player_play_get_static_delegate = new efl_player_play_get_delegate(play_get);
 422             }
 423
 424             if (methods.FirstOrDefault(m => m.Name == "GetPlay") != null)
 425             {
 426                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_play_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_get_static_delegate) });
 427             }
 428
 429             if (efl_player_play_set_static_delegate == null)
 430             {
 431                 efl_player_play_set_static_delegate = new efl_player_play_set_delegate(play_set);
 432             }
 433
 434             if (methods.FirstOrDefault(m => m.Name == "SetPlay") != null)
 435             {
 436                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_play_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_set_static_delegate) });
 437             }
 438
 439             if (efl_player_pos_get_static_delegate == null)
 440             {
 441                 efl_player_pos_get_static_delegate = new efl_player_pos_get_delegate(pos_get);
 442             }
 443
 444             if (methods.FirstOrDefault(m => m.Name == "GetPos") != null)
 445             {
 446                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_pos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_pos_get_static_delegate) });
 447             }
 448
 449             if (efl_player_pos_set_static_delegate == null)
 450             {
 451                 efl_player_pos_set_static_delegate = new efl_player_pos_set_delegate(pos_set);
 452             }
 453
 454             if (methods.FirstOrDefault(m => m.Name == "SetPos") != null)
 455             {
 456                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_pos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_pos_set_static_delegate) });
 457             }
 458
 459             if (efl_player_progress_get_static_delegate == null)
 460             {
 461                 efl_player_progress_get_static_delegate = new efl_player_progress_get_delegate(progress_get);
 462             }
 463
 464             if (methods.FirstOrDefault(m => m.Name == "GetProgress") != null)
 465             {
 466                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_progress_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_progress_get_static_delegate) });
 467             }
 468
 469             if (efl_player_play_speed_get_static_delegate == null)
 470             {
 471                 efl_player_play_speed_get_static_delegate = new efl_player_play_speed_get_delegate(play_speed_get);
 472             }
 473
 474             if (methods.FirstOrDefault(m => m.Name == "GetPlaySpeed") != null)
 475             {
 476                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_play_speed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_speed_get_static_delegate) });
 477             }
 478
 479             if (efl_player_play_speed_set_static_delegate == null)
 480             {
 481                 efl_player_play_speed_set_static_delegate = new efl_player_play_speed_set_delegate(play_speed_set);
 482             }
 483
 484             if (methods.FirstOrDefault(m => m.Name == "SetPlaySpeed") != null)
 485             {
 486                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_play_speed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_play_speed_set_static_delegate) });
 487             }
 488
 489             if (efl_player_volume_get_static_delegate == null)
 490             {
 491                 efl_player_volume_get_static_delegate = new efl_player_volume_get_delegate(volume_get);
 492             }
 493
 494             if (methods.FirstOrDefault(m => m.Name == "GetVolume") != null)
 495             {
 496                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_volume_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_volume_get_static_delegate) });
 497             }
 498
 499             if (efl_player_volume_set_static_delegate == null)
 500             {
 501                 efl_player_volume_set_static_delegate = new efl_player_volume_set_delegate(volume_set);
 502             }
 503
 504             if (methods.FirstOrDefault(m => m.Name == "SetVolume") != null)
 505             {
 506                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_volume_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_volume_set_static_delegate) });
 507             }
 508
 509             if (efl_player_mute_get_static_delegate == null)
 510             {
 511                 efl_player_mute_get_static_delegate = new efl_player_mute_get_delegate(mute_get);
 512             }
 513
 514             if (methods.FirstOrDefault(m => m.Name == "GetMute") != null)
 515             {
 516                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_mute_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_mute_get_static_delegate) });
 517             }
 518
 519             if (efl_player_mute_set_static_delegate == null)
 520             {
 521                 efl_player_mute_set_static_delegate = new efl_player_mute_set_delegate(mute_set);
 522             }
 523
 524             if (methods.FirstOrDefault(m => m.Name == "SetMute") != null)
 525             {
 526                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_mute_set"), func = Marshal.GetFunctionPointerForDelegate(efl_player_mute_set_static_delegate) });
 527             }
 528
 529             if (efl_player_length_get_static_delegate == null)
 530             {
 531                 efl_player_length_get_static_delegate = new efl_player_length_get_delegate(length_get);
 532             }
 533
 534             if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 535             {
 536                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_length_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_length_get_static_delegate) });
 537             }
 538
 539             if (efl_player_seekable_get_static_delegate == null)
 540             {
 541                 efl_player_seekable_get_static_delegate = new efl_player_seekable_get_delegate(seekable_get);
 542             }
 543
 544             if (methods.FirstOrDefault(m => m.Name == "GetSeekable") != null)
 545             {
 546                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_seekable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_player_seekable_get_static_delegate) });
 547             }
 548
 549             if (efl_player_start_static_delegate == null)
 550             {
 551                 efl_player_start_static_delegate = new efl_player_start_delegate(start);
 552             }
 553
 554             if (methods.FirstOrDefault(m => m.Name == "Start") != null)
 555             {
 556                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_start"), func = Marshal.GetFunctionPointerForDelegate(efl_player_start_static_delegate) });
 557             }
 558
 559             if (efl_player_stop_static_delegate == null)
 560             {
 561                 efl_player_stop_static_delegate = new efl_player_stop_delegate(stop);
 562             }
 563
 564             if (methods.FirstOrDefault(m => m.Name == "Stop") != null)
 565             {
 566                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_player_stop"), func = Marshal.GetFunctionPointerForDelegate(efl_player_stop_static_delegate) });
 567             }
 568
 569             return descs;
 570         }
 571         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 572         /// <returns>The native class pointer.</returns>
 573         public override IntPtr GetEflClass()
 574         {
 575             return Efl.IPlayerConcrete.efl_player_interface_get();
 576         }
 577
 578         #pragma warning disable CA1707, SA1300, SA1600
 579
 580         [return: MarshalAs(UnmanagedType.U1)]
 581         private delegate bool efl_player_playable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 582
 583         [return: MarshalAs(UnmanagedType.U1)]
 584         public delegate bool efl_player_playable_get_api_delegate(System.IntPtr obj);
 585
 586         public static Efl.Eo.FunctionWrapper<efl_player_playable_get_api_delegate> efl_player_playable_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_playable_get_api_delegate>(Module, "efl_player_playable_get");
 587
 588         private static bool playable_get(System.IntPtr obj, System.IntPtr pd)
 589         {
 590             Eina.Log.Debug("function efl_player_playable_get was called");
 591             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 592             if (wrapper != null)
 593             {
 594             bool _ret_var = default(bool);
 595                 try
 596                 {
 597                     _ret_var = ((IPlayer)wrapper).GetPlayable();
 598                 }
 599                 catch (Exception e)
 600                 {
 601                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 602                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 603                 }
 604
 605         return _ret_var;
 606
 607             }
 608             else
 609             {
 610                 return efl_player_playable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 611             }
 612         }
 613
 614         private static efl_player_playable_get_delegate efl_player_playable_get_static_delegate;
 615
 616         [return: MarshalAs(UnmanagedType.U1)]
 617         private delegate bool efl_player_play_get_delegate(System.IntPtr obj, System.IntPtr pd);
 618
 619         [return: MarshalAs(UnmanagedType.U1)]
 620         public delegate bool efl_player_play_get_api_delegate(System.IntPtr obj);
 621
 622         public static Efl.Eo.FunctionWrapper<efl_player_play_get_api_delegate> efl_player_play_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_get_api_delegate>(Module, "efl_player_play_get");
 623
 624         private static bool play_get(System.IntPtr obj, System.IntPtr pd)
 625         {
 626             Eina.Log.Debug("function efl_player_play_get was called");
 627             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 628             if (wrapper != null)
 629             {
 630             bool _ret_var = default(bool);
 631                 try
 632                 {
 633                     _ret_var = ((IPlayer)wrapper).GetPlay();
 634                 }
 635                 catch (Exception e)
 636                 {
 637                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 638                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 639                 }
 640
 641         return _ret_var;
 642
 643             }
 644             else
 645             {
 646                 return efl_player_play_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 647             }
 648         }
 649
 650         private static efl_player_play_get_delegate efl_player_play_get_static_delegate;
 651
 652
 653         private delegate void efl_player_play_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool play);
 654
 655
 656         public delegate void efl_player_play_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool play);
 657
 658         public static Efl.Eo.FunctionWrapper<efl_player_play_set_api_delegate> efl_player_play_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_set_api_delegate>(Module, "efl_player_play_set");
 659
 660         private static void play_set(System.IntPtr obj, System.IntPtr pd, bool play)
 661         {
 662             Eina.Log.Debug("function efl_player_play_set was called");
 663             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 664             if (wrapper != null)
 665             {
 666
 667                 try
 668                 {
 669                     ((IPlayer)wrapper).SetPlay(play);
 670                 }
 671                 catch (Exception e)
 672                 {
 673                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 674                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 675                 }
 676
 677
 678             }
 679             else
 680             {
 681                 efl_player_play_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), play);
 682             }
 683         }
 684
 685         private static efl_player_play_set_delegate efl_player_play_set_static_delegate;
 686
 687
 688         private delegate double efl_player_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
 689
 690
 691         public delegate double efl_player_pos_get_api_delegate(System.IntPtr obj);
 692
 693         public static Efl.Eo.FunctionWrapper<efl_player_pos_get_api_delegate> efl_player_pos_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_pos_get_api_delegate>(Module, "efl_player_pos_get");
 694
 695         private static double pos_get(System.IntPtr obj, System.IntPtr pd)
 696         {
 697             Eina.Log.Debug("function efl_player_pos_get was called");
 698             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 699             if (wrapper != null)
 700             {
 701             double _ret_var = default(double);
 702                 try
 703                 {
 704                     _ret_var = ((IPlayer)wrapper).GetPos();
 705                 }
 706                 catch (Exception e)
 707                 {
 708                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 709                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 710                 }
 711
 712         return _ret_var;
 713
 714             }
 715             else
 716             {
 717                 return efl_player_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 718             }
 719         }
 720
 721         private static efl_player_pos_get_delegate efl_player_pos_get_static_delegate;
 722
 723
 724         private delegate void efl_player_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,  double sec);
 725
 726
 727         public delegate void efl_player_pos_set_api_delegate(System.IntPtr obj,  double sec);
 728
 729         public static Efl.Eo.FunctionWrapper<efl_player_pos_set_api_delegate> efl_player_pos_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_pos_set_api_delegate>(Module, "efl_player_pos_set");
 730
 731         private static void pos_set(System.IntPtr obj, System.IntPtr pd, double sec)
 732         {
 733             Eina.Log.Debug("function efl_player_pos_set was called");
 734             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 735             if (wrapper != null)
 736             {
 737
 738                 try
 739                 {
 740                     ((IPlayer)wrapper).SetPos(sec);
 741                 }
 742                 catch (Exception e)
 743                 {
 744                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 745                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 746                 }
 747
 748
 749             }
 750             else
 751             {
 752                 efl_player_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sec);
 753             }
 754         }
 755
 756         private static efl_player_pos_set_delegate efl_player_pos_set_static_delegate;
 757
 758
 759         private delegate double efl_player_progress_get_delegate(System.IntPtr obj, System.IntPtr pd);
 760
 761
 762         public delegate double efl_player_progress_get_api_delegate(System.IntPtr obj);
 763
 764         public static Efl.Eo.FunctionWrapper<efl_player_progress_get_api_delegate> efl_player_progress_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_progress_get_api_delegate>(Module, "efl_player_progress_get");
 765
 766         private static double progress_get(System.IntPtr obj, System.IntPtr pd)
 767         {
 768             Eina.Log.Debug("function efl_player_progress_get was called");
 769             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 770             if (wrapper != null)
 771             {
 772             double _ret_var = default(double);
 773                 try
 774                 {
 775                     _ret_var = ((IPlayer)wrapper).GetProgress();
 776                 }
 777                 catch (Exception e)
 778                 {
 779                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 780                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 781                 }
 782
 783         return _ret_var;
 784
 785             }
 786             else
 787             {
 788                 return efl_player_progress_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 789             }
 790         }
 791
 792         private static efl_player_progress_get_delegate efl_player_progress_get_static_delegate;
 793
 794
 795         private delegate double efl_player_play_speed_get_delegate(System.IntPtr obj, System.IntPtr pd);
 796
 797
 798         public delegate double efl_player_play_speed_get_api_delegate(System.IntPtr obj);
 799
 800         public static Efl.Eo.FunctionWrapper<efl_player_play_speed_get_api_delegate> efl_player_play_speed_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_speed_get_api_delegate>(Module, "efl_player_play_speed_get");
 801
 802         private static double play_speed_get(System.IntPtr obj, System.IntPtr pd)
 803         {
 804             Eina.Log.Debug("function efl_player_play_speed_get was called");
 805             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 806             if (wrapper != null)
 807             {
 808             double _ret_var = default(double);
 809                 try
 810                 {
 811                     _ret_var = ((IPlayer)wrapper).GetPlaySpeed();
 812                 }
 813                 catch (Exception e)
 814                 {
 815                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 816                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 817                 }
 818
 819         return _ret_var;
 820
 821             }
 822             else
 823             {
 824                 return efl_player_play_speed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 825             }
 826         }
 827
 828         private static efl_player_play_speed_get_delegate efl_player_play_speed_get_static_delegate;
 829
 830
 831         private delegate void efl_player_play_speed_set_delegate(System.IntPtr obj, System.IntPtr pd,  double speed);
 832
 833
 834         public delegate void efl_player_play_speed_set_api_delegate(System.IntPtr obj,  double speed);
 835
 836         public static Efl.Eo.FunctionWrapper<efl_player_play_speed_set_api_delegate> efl_player_play_speed_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_play_speed_set_api_delegate>(Module, "efl_player_play_speed_set");
 837
 838         private static void play_speed_set(System.IntPtr obj, System.IntPtr pd, double speed)
 839         {
 840             Eina.Log.Debug("function efl_player_play_speed_set was called");
 841             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 842             if (wrapper != null)
 843             {
 844
 845                 try
 846                 {
 847                     ((IPlayer)wrapper).SetPlaySpeed(speed);
 848                 }
 849                 catch (Exception e)
 850                 {
 851                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 852                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 853                 }
 854
 855
 856             }
 857             else
 858             {
 859                 efl_player_play_speed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), speed);
 860             }
 861         }
 862
 863         private static efl_player_play_speed_set_delegate efl_player_play_speed_set_static_delegate;
 864
 865
 866         private delegate double efl_player_volume_get_delegate(System.IntPtr obj, System.IntPtr pd);
 867
 868
 869         public delegate double efl_player_volume_get_api_delegate(System.IntPtr obj);
 870
 871         public static Efl.Eo.FunctionWrapper<efl_player_volume_get_api_delegate> efl_player_volume_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_volume_get_api_delegate>(Module, "efl_player_volume_get");
 872
 873         private static double volume_get(System.IntPtr obj, System.IntPtr pd)
 874         {
 875             Eina.Log.Debug("function efl_player_volume_get was called");
 876             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 877             if (wrapper != null)
 878             {
 879             double _ret_var = default(double);
 880                 try
 881                 {
 882                     _ret_var = ((IPlayer)wrapper).GetVolume();
 883                 }
 884                 catch (Exception e)
 885                 {
 886                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 887                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 888                 }
 889
 890         return _ret_var;
 891
 892             }
 893             else
 894             {
 895                 return efl_player_volume_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 896             }
 897         }
 898
 899         private static efl_player_volume_get_delegate efl_player_volume_get_static_delegate;
 900
 901
 902         private delegate void efl_player_volume_set_delegate(System.IntPtr obj, System.IntPtr pd,  double volume);
 903
 904
 905         public delegate void efl_player_volume_set_api_delegate(System.IntPtr obj,  double volume);
 906
 907         public static Efl.Eo.FunctionWrapper<efl_player_volume_set_api_delegate> efl_player_volume_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_volume_set_api_delegate>(Module, "efl_player_volume_set");
 908
 909         private static void volume_set(System.IntPtr obj, System.IntPtr pd, double volume)
 910         {
 911             Eina.Log.Debug("function efl_player_volume_set was called");
 912             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 913             if (wrapper != null)
 914             {
 915
 916                 try
 917                 {
 918                     ((IPlayer)wrapper).SetVolume(volume);
 919                 }
 920                 catch (Exception e)
 921                 {
 922                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 923                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 924                 }
 925
 926
 927             }
 928             else
 929             {
 930                 efl_player_volume_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), volume);
 931             }
 932         }
 933
 934         private static efl_player_volume_set_delegate efl_player_volume_set_static_delegate;
 935
 936         [return: MarshalAs(UnmanagedType.U1)]
 937         private delegate bool efl_player_mute_get_delegate(System.IntPtr obj, System.IntPtr pd);
 938
 939         [return: MarshalAs(UnmanagedType.U1)]
 940         public delegate bool efl_player_mute_get_api_delegate(System.IntPtr obj);
 941
 942         public static Efl.Eo.FunctionWrapper<efl_player_mute_get_api_delegate> efl_player_mute_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_mute_get_api_delegate>(Module, "efl_player_mute_get");
 943
 944         private static bool mute_get(System.IntPtr obj, System.IntPtr pd)
 945         {
 946             Eina.Log.Debug("function efl_player_mute_get was called");
 947             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 948             if (wrapper != null)
 949             {
 950             bool _ret_var = default(bool);
 951                 try
 952                 {
 953                     _ret_var = ((IPlayer)wrapper).GetMute();
 954                 }
 955                 catch (Exception e)
 956                 {
 957                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 958                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 959                 }
 960
 961         return _ret_var;
 962
 963             }
 964             else
 965             {
 966                 return efl_player_mute_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 967             }
 968         }
 969
 970         private static efl_player_mute_get_delegate efl_player_mute_get_static_delegate;
 971
 972
 973         private delegate void efl_player_mute_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool mute);
 974
 975
 976         public delegate void efl_player_mute_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool mute);
 977
 978         public static Efl.Eo.FunctionWrapper<efl_player_mute_set_api_delegate> efl_player_mute_set_ptr = new Efl.Eo.FunctionWrapper<efl_player_mute_set_api_delegate>(Module, "efl_player_mute_set");
 979
 980         private static void mute_set(System.IntPtr obj, System.IntPtr pd, bool mute)
 981         {
 982             Eina.Log.Debug("function efl_player_mute_set was called");
 983             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 984             if (wrapper != null)
 985             {
 986
 987                 try
 988                 {
 989                     ((IPlayer)wrapper).SetMute(mute);
 990                 }
 991                 catch (Exception e)
 992                 {
 993                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 994                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 995                 }
 996
 997
 998             }
 999             else
1000             {
1001                 efl_player_mute_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mute);
1002             }
1003         }
1004
1005         private static efl_player_mute_set_delegate efl_player_mute_set_static_delegate;
1006
1007
1008         private delegate double efl_player_length_get_delegate(System.IntPtr obj, System.IntPtr pd);
1009
1010
1011         public delegate double efl_player_length_get_api_delegate(System.IntPtr obj);
1012
1013         public static Efl.Eo.FunctionWrapper<efl_player_length_get_api_delegate> efl_player_length_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_length_get_api_delegate>(Module, "efl_player_length_get");
1014
1015         private static double length_get(System.IntPtr obj, System.IntPtr pd)
1016         {
1017             Eina.Log.Debug("function efl_player_length_get was called");
1018             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1019             if (wrapper != null)
1020             {
1021             double _ret_var = default(double);
1022                 try
1023                 {
1024                     _ret_var = ((IPlayer)wrapper).GetLength();
1025                 }
1026                 catch (Exception e)
1027                 {
1028                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1029                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1030                 }
1031
1032         return _ret_var;
1033
1034             }
1035             else
1036             {
1037                 return efl_player_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1038             }
1039         }
1040
1041         private static efl_player_length_get_delegate efl_player_length_get_static_delegate;
1042
1043         [return: MarshalAs(UnmanagedType.U1)]
1044         private delegate bool efl_player_seekable_get_delegate(System.IntPtr obj, System.IntPtr pd);
1045
1046         [return: MarshalAs(UnmanagedType.U1)]
1047         public delegate bool efl_player_seekable_get_api_delegate(System.IntPtr obj);
1048
1049         public static Efl.Eo.FunctionWrapper<efl_player_seekable_get_api_delegate> efl_player_seekable_get_ptr = new Efl.Eo.FunctionWrapper<efl_player_seekable_get_api_delegate>(Module, "efl_player_seekable_get");
1050
1051         private static bool seekable_get(System.IntPtr obj, System.IntPtr pd)
1052         {
1053             Eina.Log.Debug("function efl_player_seekable_get was called");
1054             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1055             if (wrapper != null)
1056             {
1057             bool _ret_var = default(bool);
1058                 try
1059                 {
1060                     _ret_var = ((IPlayer)wrapper).GetSeekable();
1061                 }
1062                 catch (Exception e)
1063                 {
1064                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1065                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1066                 }
1067
1068         return _ret_var;
1069
1070             }
1071             else
1072             {
1073                 return efl_player_seekable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1074             }
1075         }
1076
1077         private static efl_player_seekable_get_delegate efl_player_seekable_get_static_delegate;
1078
1079
1080         private delegate void efl_player_start_delegate(System.IntPtr obj, System.IntPtr pd);
1081
1082
1083         public delegate void efl_player_start_api_delegate(System.IntPtr obj);
1084
1085         public static Efl.Eo.FunctionWrapper<efl_player_start_api_delegate> efl_player_start_ptr = new Efl.Eo.FunctionWrapper<efl_player_start_api_delegate>(Module, "efl_player_start");
1086
1087         private static void start(System.IntPtr obj, System.IntPtr pd)
1088         {
1089             Eina.Log.Debug("function efl_player_start was called");
1090             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1091             if (wrapper != null)
1092             {
1093
1094                 try
1095                 {
1096                     ((IPlayer)wrapper).Start();
1097                 }
1098                 catch (Exception e)
1099                 {
1100                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1101                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1102                 }
1103
1104
1105             }
1106             else
1107             {
1108                 efl_player_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1109             }
1110         }
1111
1112         private static efl_player_start_delegate efl_player_start_static_delegate;
1113
1114
1115         private delegate void efl_player_stop_delegate(System.IntPtr obj, System.IntPtr pd);
1116
1117
1118         public delegate void efl_player_stop_api_delegate(System.IntPtr obj);
1119
1120         public static Efl.Eo.FunctionWrapper<efl_player_stop_api_delegate> efl_player_stop_ptr = new Efl.Eo.FunctionWrapper<efl_player_stop_api_delegate>(Module, "efl_player_stop");
1121
1122         private static void stop(System.IntPtr obj, System.IntPtr pd)
1123         {
1124             Eina.Log.Debug("function efl_player_stop was called");
1125             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1126             if (wrapper != null)
1127             {
1128
1129                 try
1130                 {
1131                     ((IPlayer)wrapper).Stop();
1132                 }
1133                 catch (Exception e)
1134                 {
1135                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1136                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1137                 }
1138
1139
1140             }
1141             else
1142             {
1143                 efl_player_stop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1144             }
1145         }
1146
1147         private static efl_player_stop_delegate efl_player_stop_static_delegate;
1148
1149         #pragma warning restore CA1707, SA1300, SA1600
1150
1151 }
1152 }
1153 }
1154