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