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