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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Efl UI video class</summary>
  13 [Efl.Ui.Video.NativeMethods]
  14 public class Video : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.IFile,Efl.IPlayer
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(Video))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  33         efl_ui_video_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Video"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  37     public Video(Efl.Object parent
  38             , System.String style = null) : base(efl_ui_video_class_get(), typeof(Video), parent)
  39     {
  40         if (Efl.Eo.Globals.ParamHelperCheck(style))
  41         {
  42             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  43         }
  44
  45         FinishInstantiation();
  46     }
  47
  48     /// <summary>Initializes a new instance of the <see cref="Video"/> class.
  49     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  50     /// <param name="raw">The native pointer to be wrapped.</param>
  51     protected Video(System.IntPtr raw) : base(raw)
  52     {
  53             }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Video"/> class.
  56     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  57     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  58     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Video(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  61     {
  62     }
  63
  64     /// <summary>Verifies if the given object is equal to this one.</summary>
  65     /// <param name="instance">The object to compare to.</param>
  66     /// <returns>True if both objects point to the same native object.</returns>
  67     public override bool Equals(object instance)
  68     {
  69         var other = instance as Efl.Object;
  70         if (other == null)
  71         {
  72             return false;
  73         }
  74         return this.NativeHandle == other.NativeHandle;
  75     }
  76
  77     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  78     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  79     public override int GetHashCode()
  80     {
  81         return this.NativeHandle.ToInt32();
  82     }
  83
  84     /// <summary>Turns the native pointer into a string representation.</summary>
  85     /// <returns>A string with the type and the native pointer for this object.</returns>
  86     public override String ToString()
  87     {
  88         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  89     }
  90
  91     /// <summary>Set whether the object can remember the last played position.
  92     /// Note: This API only serves as indication. System support is required.</summary>
  93     /// <returns><c>true</c> when the object can remember the last position, <c>false</c> otherwise</returns>
  94     virtual public bool GetRememberPosition() {
  95          var _ret_var = Efl.Ui.Video.NativeMethods.efl_ui_video_remember_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  96         Eina.Error.RaiseIfUnhandledException();
  97         return _ret_var;
  98  }
  99     /// <summary>Set whether the object can remember the last played position.
 100     /// Note: This API only serves as indication. System support is required.</summary>
 101     /// <param name="remember"><c>true</c> when the object can remember the last position, <c>false</c> otherwise</param>
 102     virtual public void SetRememberPosition(bool remember) {
 103                                  Efl.Ui.Video.NativeMethods.efl_ui_video_remember_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),remember);
 104         Eina.Error.RaiseIfUnhandledException();
 105                          }
 106     /// <summary>Get the underlying Emotion object.</summary>
 107     /// <returns>The underlying Emotion object.</returns>
 108     virtual public Efl.Canvas.Object GetEmotion() {
 109          var _ret_var = Efl.Ui.Video.NativeMethods.efl_ui_video_emotion_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 110         Eina.Error.RaiseIfUnhandledException();
 111         return _ret_var;
 112  }
 113     /// <summary>Get the title (for instance DVD title) from this emotion object.
 114     /// This function is only useful when playing a DVD.
 115     ///
 116     /// Note: Don&apos;t change or free the string returned by this function.</summary>
 117     /// <returns>A string containing the title.</returns>
 118     virtual public System.String GetTitle() {
 119          var _ret_var = Efl.Ui.Video.NativeMethods.efl_ui_video_title_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 120         Eina.Error.RaiseIfUnhandledException();
 121         return _ret_var;
 122  }
 123     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 124     /// (Since EFL 1.22)</summary>
 125     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 126     virtual public Eina.File GetMmap() {
 127          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 128         Eina.Error.RaiseIfUnhandledException();
 129         return _ret_var;
 130  }
 131     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 132     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 133     /// (Since EFL 1.22)</summary>
 134     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 135     /// <returns>0 on success, error code otherwise</returns>
 136     virtual public Eina.Error SetMmap(Eina.File f) {
 137                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),f);
 138         Eina.Error.RaiseIfUnhandledException();
 139                         return _ret_var;
 140  }
 141     /// <summary>Retrieve the file path from where an object is to fetch the data.
 142     /// You must not modify the strings on the returned pointers.
 143     /// (Since EFL 1.22)</summary>
 144     /// <returns>The file path.</returns>
 145     virtual public System.String GetFile() {
 146          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 147         Eina.Error.RaiseIfUnhandledException();
 148         return _ret_var;
 149  }
 150     /// <summary>Set the file path from where an object will fetch the data.
 151     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 152     /// (Since EFL 1.22)</summary>
 153     /// <param name="file">The file path.</param>
 154     /// <returns>0 on success, error code otherwise</returns>
 155     virtual public Eina.Error SetFile(System.String file) {
 156                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),file);
 157         Eina.Error.RaiseIfUnhandledException();
 158                         return _ret_var;
 159  }
 160     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 161     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 162     ///
 163     /// You must not modify the strings on the returned pointers.
 164     /// (Since EFL 1.22)</summary>
 165     /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
 166     virtual public System.String GetKey() {
 167          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 168         Eina.Error.RaiseIfUnhandledException();
 169         return _ret_var;
 170  }
 171     /// <summary>Set the key which corresponds to the target data within a file.
 172     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 173     /// (Since EFL 1.22)</summary>
 174     /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
 175     virtual public void SetKey(System.String key) {
 176                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 177         Eina.Error.RaiseIfUnhandledException();
 178                          }
 179     /// <summary>Get the load state of the object.
 180     /// (Since EFL 1.22)</summary>
 181     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 182     virtual public bool GetLoaded() {
 183          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 184         Eina.Error.RaiseIfUnhandledException();
 185         return _ret_var;
 186  }
 187     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
 188     /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
 189     ///
 190     /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
 191     /// (Since EFL 1.22)</summary>
 192     /// <returns>0 on success, error code otherwise</returns>
 193     virtual public Eina.Error Load() {
 194          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 195         Eina.Error.RaiseIfUnhandledException();
 196         return _ret_var;
 197  }
 198     /// <summary>Perform all necessary operations to unload file data from the object.
 199     /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 200     ///
 201     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 202     /// (Since EFL 1.22)</summary>
 203     virtual public void Unload() {
 204          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 205         Eina.Error.RaiseIfUnhandledException();
 206          }
 207     /// <summary>Whether or not the playable can be played.</summary>
 208     /// <returns><c>true</c> if the object have playable data, <c>false</c> otherwise</returns>
 209     virtual public bool GetPlayable() {
 210          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_playable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 211         Eina.Error.RaiseIfUnhandledException();
 212         return _ret_var;
 213  }
 214     /// <summary>Get play/pause state of the media file.</summary>
 215     /// <returns><c>true</c> if playing, <c>false</c> otherwise.</returns>
 216     virtual public bool GetPlay() {
 217          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_play_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 218         Eina.Error.RaiseIfUnhandledException();
 219         return _ret_var;
 220  }
 221     /// <summary>Set play/pause state of the media file.
 222     /// 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>
 223     /// <param name="play"><c>true</c> if playing, <c>false</c> otherwise.</param>
 224     virtual public void SetPlay(bool play) {
 225                                  Efl.IPlayerConcrete.NativeMethods.efl_player_play_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),play);
 226         Eina.Error.RaiseIfUnhandledException();
 227                          }
 228     /// <summary>Get the position in the media file.
 229     /// The position is returned as the number of seconds since the beginning of the media file.</summary>
 230     /// <returns>The position (in seconds).</returns>
 231     virtual public double GetPos() {
 232          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_pos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 233         Eina.Error.RaiseIfUnhandledException();
 234         return _ret_var;
 235  }
 236     /// <summary>Set the position in the media file.
 237     /// 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>
 238     /// <param name="sec">The position (in seconds).</param>
 239     virtual public void SetPos(double sec) {
 240                                  Efl.IPlayerConcrete.NativeMethods.efl_player_pos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sec);
 241         Eina.Error.RaiseIfUnhandledException();
 242                          }
 243     /// <summary>Get how much of the file has been played.
 244     /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
 245     /// <returns>The progress within the [0, 1] range.</returns>
 246     virtual public double GetProgress() {
 247          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_progress_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 248         Eina.Error.RaiseIfUnhandledException();
 249         return _ret_var;
 250  }
 251     /// <summary>Control the play speed of the media file.
 252     /// 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>
 253     /// <returns>The play speed in the [0, infinity) range.</returns>
 254     virtual public double GetPlaySpeed() {
 255          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_play_speed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 256         Eina.Error.RaiseIfUnhandledException();
 257         return _ret_var;
 258  }
 259     /// <summary>Control the play speed of the media file.
 260     /// 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>
 261     /// <param name="speed">The play speed in the [0, infinity) range.</param>
 262     virtual public void SetPlaySpeed(double speed) {
 263                                  Efl.IPlayerConcrete.NativeMethods.efl_player_play_speed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),speed);
 264         Eina.Error.RaiseIfUnhandledException();
 265                          }
 266     /// <summary>Control the audio volume.
 267     /// 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>
 268     /// <returns>The volume level</returns>
 269     virtual public double GetVolume() {
 270          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_volume_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 271         Eina.Error.RaiseIfUnhandledException();
 272         return _ret_var;
 273  }
 274     /// <summary>Control the audio volume.
 275     /// 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>
 276     /// <param name="volume">The volume level</param>
 277     virtual public void SetVolume(double volume) {
 278                                  Efl.IPlayerConcrete.NativeMethods.efl_player_volume_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),volume);
 279         Eina.Error.RaiseIfUnhandledException();
 280                          }
 281     /// <summary>This property controls the audio mute state.</summary>
 282     /// <returns>The mute state. <c>true</c> or <c>false</c>.</returns>
 283     virtual public bool GetMute() {
 284          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_mute_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 285         Eina.Error.RaiseIfUnhandledException();
 286         return _ret_var;
 287  }
 288     /// <summary>This property controls the audio mute state.</summary>
 289     /// <param name="mute">The mute state. <c>true</c> or <c>false</c>.</param>
 290     virtual public void SetMute(bool mute) {
 291                                  Efl.IPlayerConcrete.NativeMethods.efl_player_mute_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),mute);
 292         Eina.Error.RaiseIfUnhandledException();
 293                          }
 294     /// <summary>Get the length of play for the media file.</summary>
 295     /// <returns>The length of the stream in seconds.</returns>
 296     virtual public double GetLength() {
 297          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_length_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 298         Eina.Error.RaiseIfUnhandledException();
 299         return _ret_var;
 300  }
 301     /// <summary>Get whether the media file is seekable.</summary>
 302     /// <returns><c>true</c> if seekable.</returns>
 303     virtual public bool GetSeekable() {
 304          var _ret_var = Efl.IPlayerConcrete.NativeMethods.efl_player_seekable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 305         Eina.Error.RaiseIfUnhandledException();
 306         return _ret_var;
 307  }
 308     /// <summary>Start a playing playable object.</summary>
 309     virtual public void Start() {
 310          Efl.IPlayerConcrete.NativeMethods.efl_player_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 311         Eina.Error.RaiseIfUnhandledException();
 312          }
 313     /// <summary>Stop playable object.</summary>
 314     virtual public void Stop() {
 315          Efl.IPlayerConcrete.NativeMethods.efl_player_stop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 316         Eina.Error.RaiseIfUnhandledException();
 317          }
 318     /// <summary>Set whether the object can remember the last played position.
 319 /// Note: This API only serves as indication. System support is required.</summary>
 320 /// <value><c>true</c> when the object can remember the last position, <c>false</c> otherwise</value>
 321     public bool RememberPosition {
 322         get { return GetRememberPosition(); }
 323         set { SetRememberPosition(value); }
 324     }
 325     /// <summary>Get the underlying Emotion object.</summary>
 326 /// <value>The underlying Emotion object.</value>
 327     public Efl.Canvas.Object Emotion {
 328         get { return GetEmotion(); }
 329     }
 330     /// <summary>Get the title (for instance DVD title) from this emotion object.
 331 /// This function is only useful when playing a DVD.
 332 ///
 333 /// Note: Don&apos;t change or free the string returned by this function.</summary>
 334 /// <value>A string containing the title.</value>
 335     public System.String Title {
 336         get { return GetTitle(); }
 337     }
 338     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 339 /// (Since EFL 1.22)</summary>
 340 /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 341     public Eina.File Mmap {
 342         get { return GetMmap(); }
 343         set { SetMmap(value); }
 344     }
 345     /// <summary>Retrieve the file path from where an object is to fetch the data.
 346 /// You must not modify the strings on the returned pointers.
 347 /// (Since EFL 1.22)</summary>
 348 /// <value>The file path.</value>
 349     public System.String File {
 350         get { return GetFile(); }
 351         set { SetFile(value); }
 352     }
 353     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 354 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 355 ///
 356 /// You must not modify the strings on the returned pointers.
 357 /// (Since EFL 1.22)</summary>
 358 /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
 359     public System.String Key {
 360         get { return GetKey(); }
 361         set { SetKey(value); }
 362     }
 363     /// <summary>Get the load state of the object.
 364 /// (Since EFL 1.22)</summary>
 365 /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 366     public bool Loaded {
 367         get { return GetLoaded(); }
 368     }
 369     /// <summary>Whether or not the playable can be played.</summary>
 370 /// <value><c>true</c> if the object have playable data, <c>false</c> otherwise</value>
 371     public bool Playable {
 372         get { return GetPlayable(); }
 373     }
 374     /// <summary>Get play/pause state of the media file.</summary>
 375 /// <value><c>true</c> if playing, <c>false</c> otherwise.</value>
 376     public bool Play {
 377         get { return GetPlay(); }
 378         set { SetPlay(value); }
 379     }
 380     /// <summary>Get the position in the media file.
 381 /// The position is returned as the number of seconds since the beginning of the media file.</summary>
 382 /// <value>The position (in seconds).</value>
 383     public double Pos {
 384         get { return GetPos(); }
 385         set { SetPos(value); }
 386     }
 387     /// <summary>Get how much of the file has been played.
 388 /// This function gets the progress in playing the file, the return value is in the [0, 1] range.</summary>
 389 /// <value>The progress within the [0, 1] range.</value>
 390     public double Progress {
 391         get { return GetProgress(); }
 392     }
 393     /// <summary>Control the play speed of the media file.
 394 /// 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>
 395 /// <value>The play speed in the [0, infinity) range.</value>
 396     public double PlaySpeed {
 397         get { return GetPlaySpeed(); }
 398         set { SetPlaySpeed(value); }
 399     }
 400     /// <summary>Control the audio volume.
 401 /// 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>
 402 /// <value>The volume level</value>
 403     public double Volume {
 404         get { return GetVolume(); }
 405         set { SetVolume(value); }
 406     }
 407     /// <summary>This property controls the audio mute state.</summary>
 408 /// <value>The mute state. <c>true</c> or <c>false</c>.</value>
 409     public bool Mute {
 410         get { return GetMute(); }
 411         set { SetMute(value); }
 412     }
 413     /// <summary>Get the length of play for the media file.</summary>
 414 /// <value>The length of the stream in seconds.</value>
 415     public double Length {
 416         get { return GetLength(); }
 417     }
 418     /// <summary>Get whether the media file is seekable.</summary>
 419 /// <value><c>true</c> if seekable.</value>
 420     public bool Seekable {
 421         get { return GetSeekable(); }
 422     }
 423     private static IntPtr GetEflClassStatic()
 424     {
 425         return Efl.Ui.Video.efl_ui_video_class_get();
 426     }
 427     /// <summary>Wrapper for native methods and virtual method delegates.
 428     /// For internal use by generated code only.</summary>
 429     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 430     {
 431         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 432         /// <summary>Gets the list of Eo operations to override.</summary>
 433         /// <returns>The list of Eo operations to be overload.</returns>
 434         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 435         {
 436             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 437             var methods = Efl.Eo.Globals.GetUserMethods(type);
 438
 439             if (efl_ui_video_remember_position_get_static_delegate == null)
 440             {
 441                 efl_ui_video_remember_position_get_static_delegate = new efl_ui_video_remember_position_get_delegate(remember_position_get);
 442             }
 443
 444             if (methods.FirstOrDefault(m => m.Name == "GetRememberPosition") != null)
 445             {
 446                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_video_remember_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_video_remember_position_get_static_delegate) });
 447             }
 448
 449             if (efl_ui_video_remember_position_set_static_delegate == null)
 450             {
 451                 efl_ui_video_remember_position_set_static_delegate = new efl_ui_video_remember_position_set_delegate(remember_position_set);
 452             }
 453
 454             if (methods.FirstOrDefault(m => m.Name == "SetRememberPosition") != null)
 455             {
 456                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_video_remember_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_video_remember_position_set_static_delegate) });
 457             }
 458
 459             if (efl_ui_video_emotion_get_static_delegate == null)
 460             {
 461                 efl_ui_video_emotion_get_static_delegate = new efl_ui_video_emotion_get_delegate(emotion_get);
 462             }
 463
 464             if (methods.FirstOrDefault(m => m.Name == "GetEmotion") != null)
 465             {
 466                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_video_emotion_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_video_emotion_get_static_delegate) });
 467             }
 468
 469             if (efl_ui_video_title_get_static_delegate == null)
 470             {
 471                 efl_ui_video_title_get_static_delegate = new efl_ui_video_title_get_delegate(title_get);
 472             }
 473
 474             if (methods.FirstOrDefault(m => m.Name == "GetTitle") != null)
 475             {
 476                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_video_title_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_video_title_get_static_delegate) });
 477             }
 478
 479             if (efl_file_mmap_get_static_delegate == null)
 480             {
 481                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 482             }
 483
 484             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 485             {
 486                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate) });
 487             }
 488
 489             if (efl_file_mmap_set_static_delegate == null)
 490             {
 491                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 492             }
 493
 494             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 495             {
 496                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate) });
 497             }
 498
 499             if (efl_file_get_static_delegate == null)
 500             {
 501                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 502             }
 503
 504             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 505             {
 506                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate) });
 507             }
 508
 509             if (efl_file_set_static_delegate == null)
 510             {
 511                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 512             }
 513
 514             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 515             {
 516                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate) });
 517             }
 518
 519             if (efl_file_key_get_static_delegate == null)
 520             {
 521                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 522             }
 523
 524             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 525             {
 526                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate) });
 527             }
 528
 529             if (efl_file_key_set_static_delegate == null)
 530             {
 531                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 532             }
 533
 534             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 535             {
 536                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate) });
 537             }
 538
 539             if (efl_file_loaded_get_static_delegate == null)
 540             {
 541                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 542             }
 543
 544             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 545             {
 546                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate) });
 547             }
 548
 549             if (efl_file_load_static_delegate == null)
 550             {
 551                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 552             }
 553
 554             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 555             {
 556                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate) });
 557             }
 558
 559             if (efl_file_unload_static_delegate == null)
 560             {
 561                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 562             }
 563
 564             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 565             {
 566                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate) });
 567             }
 568
 569             if (efl_player_playable_get_static_delegate == null)
 570             {
 571                 efl_player_playable_get_static_delegate = new efl_player_playable_get_delegate(playable_get);
 572             }
 573
 574             if (methods.FirstOrDefault(m => m.Name == "GetPlayable") != null)
 575             {
 576                 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) });
 577             }
 578
 579             if (efl_player_play_get_static_delegate == null)
 580             {
 581                 efl_player_play_get_static_delegate = new efl_player_play_get_delegate(play_get);
 582             }
 583
 584             if (methods.FirstOrDefault(m => m.Name == "GetPlay") != null)
 585             {
 586                 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) });
 587             }
 588
 589             if (efl_player_play_set_static_delegate == null)
 590             {
 591                 efl_player_play_set_static_delegate = new efl_player_play_set_delegate(play_set);
 592             }
 593
 594             if (methods.FirstOrDefault(m => m.Name == "SetPlay") != null)
 595             {
 596                 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) });
 597             }
 598
 599             if (efl_player_pos_get_static_delegate == null)
 600             {
 601                 efl_player_pos_get_static_delegate = new efl_player_pos_get_delegate(pos_get);
 602             }
 603
 604             if (methods.FirstOrDefault(m => m.Name == "GetPos") != null)
 605             {
 606                 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) });
 607             }
 608
 609             if (efl_player_pos_set_static_delegate == null)
 610             {
 611                 efl_player_pos_set_static_delegate = new efl_player_pos_set_delegate(pos_set);
 612             }
 613
 614             if (methods.FirstOrDefault(m => m.Name == "SetPos") != null)
 615             {
 616                 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) });
 617             }
 618
 619             if (efl_player_progress_get_static_delegate == null)
 620             {
 621                 efl_player_progress_get_static_delegate = new efl_player_progress_get_delegate(progress_get);
 622             }
 623
 624             if (methods.FirstOrDefault(m => m.Name == "GetProgress") != null)
 625             {
 626                 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) });
 627             }
 628
 629             if (efl_player_play_speed_get_static_delegate == null)
 630             {
 631                 efl_player_play_speed_get_static_delegate = new efl_player_play_speed_get_delegate(play_speed_get);
 632             }
 633
 634             if (methods.FirstOrDefault(m => m.Name == "GetPlaySpeed") != null)
 635             {
 636                 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) });
 637             }
 638
 639             if (efl_player_play_speed_set_static_delegate == null)
 640             {
 641                 efl_player_play_speed_set_static_delegate = new efl_player_play_speed_set_delegate(play_speed_set);
 642             }
 643
 644             if (methods.FirstOrDefault(m => m.Name == "SetPlaySpeed") != null)
 645             {
 646                 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) });
 647             }
 648
 649             if (efl_player_volume_get_static_delegate == null)
 650             {
 651                 efl_player_volume_get_static_delegate = new efl_player_volume_get_delegate(volume_get);
 652             }
 653
 654             if (methods.FirstOrDefault(m => m.Name == "GetVolume") != null)
 655             {
 656                 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) });
 657             }
 658
 659             if (efl_player_volume_set_static_delegate == null)
 660             {
 661                 efl_player_volume_set_static_delegate = new efl_player_volume_set_delegate(volume_set);
 662             }
 663
 664             if (methods.FirstOrDefault(m => m.Name == "SetVolume") != null)
 665             {
 666                 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) });
 667             }
 668
 669             if (efl_player_mute_get_static_delegate == null)
 670             {
 671                 efl_player_mute_get_static_delegate = new efl_player_mute_get_delegate(mute_get);
 672             }
 673
 674             if (methods.FirstOrDefault(m => m.Name == "GetMute") != null)
 675             {
 676                 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) });
 677             }
 678
 679             if (efl_player_mute_set_static_delegate == null)
 680             {
 681                 efl_player_mute_set_static_delegate = new efl_player_mute_set_delegate(mute_set);
 682             }
 683
 684             if (methods.FirstOrDefault(m => m.Name == "SetMute") != null)
 685             {
 686                 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) });
 687             }
 688
 689             if (efl_player_length_get_static_delegate == null)
 690             {
 691                 efl_player_length_get_static_delegate = new efl_player_length_get_delegate(length_get);
 692             }
 693
 694             if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 695             {
 696                 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) });
 697             }
 698
 699             if (efl_player_seekable_get_static_delegate == null)
 700             {
 701                 efl_player_seekable_get_static_delegate = new efl_player_seekable_get_delegate(seekable_get);
 702             }
 703
 704             if (methods.FirstOrDefault(m => m.Name == "GetSeekable") != null)
 705             {
 706                 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) });
 707             }
 708
 709             if (efl_player_start_static_delegate == null)
 710             {
 711                 efl_player_start_static_delegate = new efl_player_start_delegate(start);
 712             }
 713
 714             if (methods.FirstOrDefault(m => m.Name == "Start") != null)
 715             {
 716                 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) });
 717             }
 718
 719             if (efl_player_stop_static_delegate == null)
 720             {
 721                 efl_player_stop_static_delegate = new efl_player_stop_delegate(stop);
 722             }
 723
 724             if (methods.FirstOrDefault(m => m.Name == "Stop") != null)
 725             {
 726                 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) });
 727             }
 728
 729             descs.AddRange(base.GetEoOps(type));
 730             return descs;
 731         }
 732         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 733         /// <returns>The native class pointer.</returns>
 734         public override IntPtr GetEflClass()
 735         {
 736             return Efl.Ui.Video.efl_ui_video_class_get();
 737         }
 738
 739         #pragma warning disable CA1707, SA1300, SA1600
 740
 741         [return: MarshalAs(UnmanagedType.U1)]
 742         private delegate bool efl_ui_video_remember_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
 743
 744         [return: MarshalAs(UnmanagedType.U1)]
 745         public delegate bool efl_ui_video_remember_position_get_api_delegate(System.IntPtr obj);
 746
 747         public static Efl.Eo.FunctionWrapper<efl_ui_video_remember_position_get_api_delegate> efl_ui_video_remember_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_video_remember_position_get_api_delegate>(Module, "efl_ui_video_remember_position_get");
 748
 749         private static bool remember_position_get(System.IntPtr obj, System.IntPtr pd)
 750         {
 751             Eina.Log.Debug("function efl_ui_video_remember_position_get was called");
 752             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 753             if (wrapper != null)
 754             {
 755             bool _ret_var = default(bool);
 756                 try
 757                 {
 758                     _ret_var = ((Video)wrapper).GetRememberPosition();
 759                 }
 760                 catch (Exception e)
 761                 {
 762                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 763                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 764                 }
 765
 766         return _ret_var;
 767
 768             }
 769             else
 770             {
 771                 return efl_ui_video_remember_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 772             }
 773         }
 774
 775         private static efl_ui_video_remember_position_get_delegate efl_ui_video_remember_position_get_static_delegate;
 776
 777
 778         private delegate void efl_ui_video_remember_position_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool remember);
 779
 780
 781         public delegate void efl_ui_video_remember_position_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool remember);
 782
 783         public static Efl.Eo.FunctionWrapper<efl_ui_video_remember_position_set_api_delegate> efl_ui_video_remember_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_video_remember_position_set_api_delegate>(Module, "efl_ui_video_remember_position_set");
 784
 785         private static void remember_position_set(System.IntPtr obj, System.IntPtr pd, bool remember)
 786         {
 787             Eina.Log.Debug("function efl_ui_video_remember_position_set was called");
 788             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 789             if (wrapper != null)
 790             {
 791
 792                 try
 793                 {
 794                     ((Video)wrapper).SetRememberPosition(remember);
 795                 }
 796                 catch (Exception e)
 797                 {
 798                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 799                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 800                 }
 801
 802
 803             }
 804             else
 805             {
 806                 efl_ui_video_remember_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), remember);
 807             }
 808         }
 809
 810         private static efl_ui_video_remember_position_set_delegate efl_ui_video_remember_position_set_static_delegate;
 811
 812         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 813         private delegate Efl.Canvas.Object efl_ui_video_emotion_get_delegate(System.IntPtr obj, System.IntPtr pd);
 814
 815         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 816         public delegate Efl.Canvas.Object efl_ui_video_emotion_get_api_delegate(System.IntPtr obj);
 817
 818         public static Efl.Eo.FunctionWrapper<efl_ui_video_emotion_get_api_delegate> efl_ui_video_emotion_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_video_emotion_get_api_delegate>(Module, "efl_ui_video_emotion_get");
 819
 820         private static Efl.Canvas.Object emotion_get(System.IntPtr obj, System.IntPtr pd)
 821         {
 822             Eina.Log.Debug("function efl_ui_video_emotion_get was called");
 823             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 824             if (wrapper != null)
 825             {
 826             Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
 827                 try
 828                 {
 829                     _ret_var = ((Video)wrapper).GetEmotion();
 830                 }
 831                 catch (Exception e)
 832                 {
 833                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 834                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 835                 }
 836
 837         return _ret_var;
 838
 839             }
 840             else
 841             {
 842                 return efl_ui_video_emotion_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 843             }
 844         }
 845
 846         private static efl_ui_video_emotion_get_delegate efl_ui_video_emotion_get_static_delegate;
 847
 848         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 849         private delegate System.String efl_ui_video_title_get_delegate(System.IntPtr obj, System.IntPtr pd);
 850
 851         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 852         public delegate System.String efl_ui_video_title_get_api_delegate(System.IntPtr obj);
 853
 854         public static Efl.Eo.FunctionWrapper<efl_ui_video_title_get_api_delegate> efl_ui_video_title_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_video_title_get_api_delegate>(Module, "efl_ui_video_title_get");
 855
 856         private static System.String title_get(System.IntPtr obj, System.IntPtr pd)
 857         {
 858             Eina.Log.Debug("function efl_ui_video_title_get was called");
 859             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 860             if (wrapper != null)
 861             {
 862             System.String _ret_var = default(System.String);
 863                 try
 864                 {
 865                     _ret_var = ((Video)wrapper).GetTitle();
 866                 }
 867                 catch (Exception e)
 868                 {
 869                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 870                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 871                 }
 872
 873         return _ret_var;
 874
 875             }
 876             else
 877             {
 878                 return efl_ui_video_title_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 879             }
 880         }
 881
 882         private static efl_ui_video_title_get_delegate efl_ui_video_title_get_static_delegate;
 883
 884
 885         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 886
 887
 888         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 889
 890         public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(Module, "efl_file_mmap_get");
 891
 892         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 893         {
 894             Eina.Log.Debug("function efl_file_mmap_get was called");
 895             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 896             if (wrapper != null)
 897             {
 898             Eina.File _ret_var = default(Eina.File);
 899                 try
 900                 {
 901                     _ret_var = ((Video)wrapper).GetMmap();
 902                 }
 903                 catch (Exception e)
 904                 {
 905                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 906                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 907                 }
 908
 909         return _ret_var;
 910
 911             }
 912             else
 913             {
 914                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 915             }
 916         }
 917
 918         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 919
 920
 921         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
 922
 923
 924         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
 925
 926         public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(Module, "efl_file_mmap_set");
 927
 928         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
 929         {
 930             Eina.Log.Debug("function efl_file_mmap_set was called");
 931             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 932             if (wrapper != null)
 933             {
 934                                     Eina.Error _ret_var = default(Eina.Error);
 935                 try
 936                 {
 937                     _ret_var = ((Video)wrapper).SetMmap(f);
 938                 }
 939                 catch (Exception e)
 940                 {
 941                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 942                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 943                 }
 944
 945                         return _ret_var;
 946
 947             }
 948             else
 949             {
 950                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 951             }
 952         }
 953
 954         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 955
 956         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 957         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 958
 959         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 960         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
 961
 962         public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(Module, "efl_file_get");
 963
 964         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
 965         {
 966             Eina.Log.Debug("function efl_file_get was called");
 967             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 968             if (wrapper != null)
 969             {
 970             System.String _ret_var = default(System.String);
 971                 try
 972                 {
 973                     _ret_var = ((Video)wrapper).GetFile();
 974                 }
 975                 catch (Exception e)
 976                 {
 977                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 978                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 979                 }
 980
 981         return _ret_var;
 982
 983             }
 984             else
 985             {
 986                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 987             }
 988         }
 989
 990         private static efl_file_get_delegate efl_file_get_static_delegate;
 991
 992
 993         private delegate Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
 994
 995
 996         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
 997
 998         public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(Module, "efl_file_set");
 999
1000         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1001         {
1002             Eina.Log.Debug("function efl_file_set was called");
1003             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1004             if (wrapper != null)
1005             {
1006                                     Eina.Error _ret_var = default(Eina.Error);
1007                 try
1008                 {
1009                     _ret_var = ((Video)wrapper).SetFile(file);
1010                 }
1011                 catch (Exception e)
1012                 {
1013                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1014                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1015                 }
1016
1017                         return _ret_var;
1018
1019             }
1020             else
1021             {
1022                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1023             }
1024         }
1025
1026         private static efl_file_set_delegate efl_file_set_static_delegate;
1027
1028         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1029         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1030
1031         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1032         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1033
1034         public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(Module, "efl_file_key_get");
1035
1036         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1037         {
1038             Eina.Log.Debug("function efl_file_key_get was called");
1039             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1040             if (wrapper != null)
1041             {
1042             System.String _ret_var = default(System.String);
1043                 try
1044                 {
1045                     _ret_var = ((Video)wrapper).GetKey();
1046                 }
1047                 catch (Exception e)
1048                 {
1049                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1050                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1051                 }
1052
1053         return _ret_var;
1054
1055             }
1056             else
1057             {
1058                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1059             }
1060         }
1061
1062         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1063
1064
1065         private delegate void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1066
1067
1068         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1069
1070         public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(Module, "efl_file_key_set");
1071
1072         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1073         {
1074             Eina.Log.Debug("function efl_file_key_set was called");
1075             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1076             if (wrapper != null)
1077             {
1078
1079                 try
1080                 {
1081                     ((Video)wrapper).SetKey(key);
1082                 }
1083                 catch (Exception e)
1084                 {
1085                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1086                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1087                 }
1088
1089
1090             }
1091             else
1092             {
1093                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1094             }
1095         }
1096
1097         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1098
1099         [return: MarshalAs(UnmanagedType.U1)]
1100         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1101
1102         [return: MarshalAs(UnmanagedType.U1)]
1103         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1104
1105         public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(Module, "efl_file_loaded_get");
1106
1107         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1108         {
1109             Eina.Log.Debug("function efl_file_loaded_get was called");
1110             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1111             if (wrapper != null)
1112             {
1113             bool _ret_var = default(bool);
1114                 try
1115                 {
1116                     _ret_var = ((Video)wrapper).GetLoaded();
1117                 }
1118                 catch (Exception e)
1119                 {
1120                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1121                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1122                 }
1123
1124         return _ret_var;
1125
1126             }
1127             else
1128             {
1129                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1130             }
1131         }
1132
1133         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1134
1135
1136         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1137
1138
1139         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1140
1141         public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(Module, "efl_file_load");
1142
1143         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1144         {
1145             Eina.Log.Debug("function efl_file_load was called");
1146             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1147             if (wrapper != null)
1148             {
1149             Eina.Error _ret_var = default(Eina.Error);
1150                 try
1151                 {
1152                     _ret_var = ((Video)wrapper).Load();
1153                 }
1154                 catch (Exception e)
1155                 {
1156                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1157                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1158                 }
1159
1160         return _ret_var;
1161
1162             }
1163             else
1164             {
1165                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1166             }
1167         }
1168
1169         private static efl_file_load_delegate efl_file_load_static_delegate;
1170
1171
1172         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1173
1174
1175         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1176
1177         public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(Module, "efl_file_unload");
1178
1179         private static void unload(System.IntPtr obj, System.IntPtr pd)
1180         {
1181             Eina.Log.Debug("function efl_file_unload was called");
1182             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1183             if (wrapper != null)
1184             {
1185
1186                 try
1187                 {
1188                     ((Video)wrapper).Unload();
1189                 }
1190                 catch (Exception e)
1191                 {
1192                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1193                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1194                 }
1195
1196
1197             }
1198             else
1199             {
1200                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1201             }
1202         }
1203
1204         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1205
1206         [return: MarshalAs(UnmanagedType.U1)]
1207         private delegate bool efl_player_playable_get_delegate(System.IntPtr obj, System.IntPtr pd);
1208
1209         [return: MarshalAs(UnmanagedType.U1)]
1210         public delegate bool efl_player_playable_get_api_delegate(System.IntPtr obj);
1211
1212         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");
1213
1214         private static bool playable_get(System.IntPtr obj, System.IntPtr pd)
1215         {
1216             Eina.Log.Debug("function efl_player_playable_get was called");
1217             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1218             if (wrapper != null)
1219             {
1220             bool _ret_var = default(bool);
1221                 try
1222                 {
1223                     _ret_var = ((Video)wrapper).GetPlayable();
1224                 }
1225                 catch (Exception e)
1226                 {
1227                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1228                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1229                 }
1230
1231         return _ret_var;
1232
1233             }
1234             else
1235             {
1236                 return efl_player_playable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1237             }
1238         }
1239
1240         private static efl_player_playable_get_delegate efl_player_playable_get_static_delegate;
1241
1242         [return: MarshalAs(UnmanagedType.U1)]
1243         private delegate bool efl_player_play_get_delegate(System.IntPtr obj, System.IntPtr pd);
1244
1245         [return: MarshalAs(UnmanagedType.U1)]
1246         public delegate bool efl_player_play_get_api_delegate(System.IntPtr obj);
1247
1248         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");
1249
1250         private static bool play_get(System.IntPtr obj, System.IntPtr pd)
1251         {
1252             Eina.Log.Debug("function efl_player_play_get was called");
1253             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1254             if (wrapper != null)
1255             {
1256             bool _ret_var = default(bool);
1257                 try
1258                 {
1259                     _ret_var = ((Video)wrapper).GetPlay();
1260                 }
1261                 catch (Exception e)
1262                 {
1263                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1264                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1265                 }
1266
1267         return _ret_var;
1268
1269             }
1270             else
1271             {
1272                 return efl_player_play_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1273             }
1274         }
1275
1276         private static efl_player_play_get_delegate efl_player_play_get_static_delegate;
1277
1278
1279         private delegate void efl_player_play_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool play);
1280
1281
1282         public delegate void efl_player_play_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool play);
1283
1284         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");
1285
1286         private static void play_set(System.IntPtr obj, System.IntPtr pd, bool play)
1287         {
1288             Eina.Log.Debug("function efl_player_play_set was called");
1289             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1290             if (wrapper != null)
1291             {
1292
1293                 try
1294                 {
1295                     ((Video)wrapper).SetPlay(play);
1296                 }
1297                 catch (Exception e)
1298                 {
1299                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1300                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1301                 }
1302
1303
1304             }
1305             else
1306             {
1307                 efl_player_play_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), play);
1308             }
1309         }
1310
1311         private static efl_player_play_set_delegate efl_player_play_set_static_delegate;
1312
1313
1314         private delegate double efl_player_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
1315
1316
1317         public delegate double efl_player_pos_get_api_delegate(System.IntPtr obj);
1318
1319         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");
1320
1321         private static double pos_get(System.IntPtr obj, System.IntPtr pd)
1322         {
1323             Eina.Log.Debug("function efl_player_pos_get was called");
1324             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1325             if (wrapper != null)
1326             {
1327             double _ret_var = default(double);
1328                 try
1329                 {
1330                     _ret_var = ((Video)wrapper).GetPos();
1331                 }
1332                 catch (Exception e)
1333                 {
1334                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1335                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1336                 }
1337
1338         return _ret_var;
1339
1340             }
1341             else
1342             {
1343                 return efl_player_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1344             }
1345         }
1346
1347         private static efl_player_pos_get_delegate efl_player_pos_get_static_delegate;
1348
1349
1350         private delegate void efl_player_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,  double sec);
1351
1352
1353         public delegate void efl_player_pos_set_api_delegate(System.IntPtr obj,  double sec);
1354
1355         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");
1356
1357         private static void pos_set(System.IntPtr obj, System.IntPtr pd, double sec)
1358         {
1359             Eina.Log.Debug("function efl_player_pos_set was called");
1360             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1361             if (wrapper != null)
1362             {
1363
1364                 try
1365                 {
1366                     ((Video)wrapper).SetPos(sec);
1367                 }
1368                 catch (Exception e)
1369                 {
1370                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1371                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1372                 }
1373
1374
1375             }
1376             else
1377             {
1378                 efl_player_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sec);
1379             }
1380         }
1381
1382         private static efl_player_pos_set_delegate efl_player_pos_set_static_delegate;
1383
1384
1385         private delegate double efl_player_progress_get_delegate(System.IntPtr obj, System.IntPtr pd);
1386
1387
1388         public delegate double efl_player_progress_get_api_delegate(System.IntPtr obj);
1389
1390         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");
1391
1392         private static double progress_get(System.IntPtr obj, System.IntPtr pd)
1393         {
1394             Eina.Log.Debug("function efl_player_progress_get was called");
1395             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1396             if (wrapper != null)
1397             {
1398             double _ret_var = default(double);
1399                 try
1400                 {
1401                     _ret_var = ((Video)wrapper).GetProgress();
1402                 }
1403                 catch (Exception e)
1404                 {
1405                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1406                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1407                 }
1408
1409         return _ret_var;
1410
1411             }
1412             else
1413             {
1414                 return efl_player_progress_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1415             }
1416         }
1417
1418         private static efl_player_progress_get_delegate efl_player_progress_get_static_delegate;
1419
1420
1421         private delegate double efl_player_play_speed_get_delegate(System.IntPtr obj, System.IntPtr pd);
1422
1423
1424         public delegate double efl_player_play_speed_get_api_delegate(System.IntPtr obj);
1425
1426         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");
1427
1428         private static double play_speed_get(System.IntPtr obj, System.IntPtr pd)
1429         {
1430             Eina.Log.Debug("function efl_player_play_speed_get was called");
1431             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1432             if (wrapper != null)
1433             {
1434             double _ret_var = default(double);
1435                 try
1436                 {
1437                     _ret_var = ((Video)wrapper).GetPlaySpeed();
1438                 }
1439                 catch (Exception e)
1440                 {
1441                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1442                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1443                 }
1444
1445         return _ret_var;
1446
1447             }
1448             else
1449             {
1450                 return efl_player_play_speed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1451             }
1452         }
1453
1454         private static efl_player_play_speed_get_delegate efl_player_play_speed_get_static_delegate;
1455
1456
1457         private delegate void efl_player_play_speed_set_delegate(System.IntPtr obj, System.IntPtr pd,  double speed);
1458
1459
1460         public delegate void efl_player_play_speed_set_api_delegate(System.IntPtr obj,  double speed);
1461
1462         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");
1463
1464         private static void play_speed_set(System.IntPtr obj, System.IntPtr pd, double speed)
1465         {
1466             Eina.Log.Debug("function efl_player_play_speed_set was called");
1467             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1468             if (wrapper != null)
1469             {
1470
1471                 try
1472                 {
1473                     ((Video)wrapper).SetPlaySpeed(speed);
1474                 }
1475                 catch (Exception e)
1476                 {
1477                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1478                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1479                 }
1480
1481
1482             }
1483             else
1484             {
1485                 efl_player_play_speed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), speed);
1486             }
1487         }
1488
1489         private static efl_player_play_speed_set_delegate efl_player_play_speed_set_static_delegate;
1490
1491
1492         private delegate double efl_player_volume_get_delegate(System.IntPtr obj, System.IntPtr pd);
1493
1494
1495         public delegate double efl_player_volume_get_api_delegate(System.IntPtr obj);
1496
1497         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");
1498
1499         private static double volume_get(System.IntPtr obj, System.IntPtr pd)
1500         {
1501             Eina.Log.Debug("function efl_player_volume_get was called");
1502             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1503             if (wrapper != null)
1504             {
1505             double _ret_var = default(double);
1506                 try
1507                 {
1508                     _ret_var = ((Video)wrapper).GetVolume();
1509                 }
1510                 catch (Exception e)
1511                 {
1512                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1513                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1514                 }
1515
1516         return _ret_var;
1517
1518             }
1519             else
1520             {
1521                 return efl_player_volume_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1522             }
1523         }
1524
1525         private static efl_player_volume_get_delegate efl_player_volume_get_static_delegate;
1526
1527
1528         private delegate void efl_player_volume_set_delegate(System.IntPtr obj, System.IntPtr pd,  double volume);
1529
1530
1531         public delegate void efl_player_volume_set_api_delegate(System.IntPtr obj,  double volume);
1532
1533         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");
1534
1535         private static void volume_set(System.IntPtr obj, System.IntPtr pd, double volume)
1536         {
1537             Eina.Log.Debug("function efl_player_volume_set was called");
1538             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1539             if (wrapper != null)
1540             {
1541
1542                 try
1543                 {
1544                     ((Video)wrapper).SetVolume(volume);
1545                 }
1546                 catch (Exception e)
1547                 {
1548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1550                 }
1551
1552
1553             }
1554             else
1555             {
1556                 efl_player_volume_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), volume);
1557             }
1558         }
1559
1560         private static efl_player_volume_set_delegate efl_player_volume_set_static_delegate;
1561
1562         [return: MarshalAs(UnmanagedType.U1)]
1563         private delegate bool efl_player_mute_get_delegate(System.IntPtr obj, System.IntPtr pd);
1564
1565         [return: MarshalAs(UnmanagedType.U1)]
1566         public delegate bool efl_player_mute_get_api_delegate(System.IntPtr obj);
1567
1568         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");
1569
1570         private static bool mute_get(System.IntPtr obj, System.IntPtr pd)
1571         {
1572             Eina.Log.Debug("function efl_player_mute_get was called");
1573             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1574             if (wrapper != null)
1575             {
1576             bool _ret_var = default(bool);
1577                 try
1578                 {
1579                     _ret_var = ((Video)wrapper).GetMute();
1580                 }
1581                 catch (Exception e)
1582                 {
1583                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1584                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1585                 }
1586
1587         return _ret_var;
1588
1589             }
1590             else
1591             {
1592                 return efl_player_mute_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1593             }
1594         }
1595
1596         private static efl_player_mute_get_delegate efl_player_mute_get_static_delegate;
1597
1598
1599         private delegate void efl_player_mute_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool mute);
1600
1601
1602         public delegate void efl_player_mute_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool mute);
1603
1604         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");
1605
1606         private static void mute_set(System.IntPtr obj, System.IntPtr pd, bool mute)
1607         {
1608             Eina.Log.Debug("function efl_player_mute_set was called");
1609             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1610             if (wrapper != null)
1611             {
1612
1613                 try
1614                 {
1615                     ((Video)wrapper).SetMute(mute);
1616                 }
1617                 catch (Exception e)
1618                 {
1619                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1620                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1621                 }
1622
1623
1624             }
1625             else
1626             {
1627                 efl_player_mute_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mute);
1628             }
1629         }
1630
1631         private static efl_player_mute_set_delegate efl_player_mute_set_static_delegate;
1632
1633
1634         private delegate double efl_player_length_get_delegate(System.IntPtr obj, System.IntPtr pd);
1635
1636
1637         public delegate double efl_player_length_get_api_delegate(System.IntPtr obj);
1638
1639         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");
1640
1641         private static double length_get(System.IntPtr obj, System.IntPtr pd)
1642         {
1643             Eina.Log.Debug("function efl_player_length_get was called");
1644             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1645             if (wrapper != null)
1646             {
1647             double _ret_var = default(double);
1648                 try
1649                 {
1650                     _ret_var = ((Video)wrapper).GetLength();
1651                 }
1652                 catch (Exception e)
1653                 {
1654                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1655                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1656                 }
1657
1658         return _ret_var;
1659
1660             }
1661             else
1662             {
1663                 return efl_player_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1664             }
1665         }
1666
1667         private static efl_player_length_get_delegate efl_player_length_get_static_delegate;
1668
1669         [return: MarshalAs(UnmanagedType.U1)]
1670         private delegate bool efl_player_seekable_get_delegate(System.IntPtr obj, System.IntPtr pd);
1671
1672         [return: MarshalAs(UnmanagedType.U1)]
1673         public delegate bool efl_player_seekable_get_api_delegate(System.IntPtr obj);
1674
1675         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");
1676
1677         private static bool seekable_get(System.IntPtr obj, System.IntPtr pd)
1678         {
1679             Eina.Log.Debug("function efl_player_seekable_get was called");
1680             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1681             if (wrapper != null)
1682             {
1683             bool _ret_var = default(bool);
1684                 try
1685                 {
1686                     _ret_var = ((Video)wrapper).GetSeekable();
1687                 }
1688                 catch (Exception e)
1689                 {
1690                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1691                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1692                 }
1693
1694         return _ret_var;
1695
1696             }
1697             else
1698             {
1699                 return efl_player_seekable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1700             }
1701         }
1702
1703         private static efl_player_seekable_get_delegate efl_player_seekable_get_static_delegate;
1704
1705
1706         private delegate void efl_player_start_delegate(System.IntPtr obj, System.IntPtr pd);
1707
1708
1709         public delegate void efl_player_start_api_delegate(System.IntPtr obj);
1710
1711         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");
1712
1713         private static void start(System.IntPtr obj, System.IntPtr pd)
1714         {
1715             Eina.Log.Debug("function efl_player_start was called");
1716             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1717             if (wrapper != null)
1718             {
1719
1720                 try
1721                 {
1722                     ((Video)wrapper).Start();
1723                 }
1724                 catch (Exception e)
1725                 {
1726                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1727                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1728                 }
1729
1730
1731             }
1732             else
1733             {
1734                 efl_player_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1735             }
1736         }
1737
1738         private static efl_player_start_delegate efl_player_start_static_delegate;
1739
1740
1741         private delegate void efl_player_stop_delegate(System.IntPtr obj, System.IntPtr pd);
1742
1743
1744         public delegate void efl_player_stop_api_delegate(System.IntPtr obj);
1745
1746         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");
1747
1748         private static void stop(System.IntPtr obj, System.IntPtr pd)
1749         {
1750             Eina.Log.Debug("function efl_player_stop was called");
1751             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1752             if (wrapper != null)
1753             {
1754
1755                 try
1756                 {
1757                     ((Video)wrapper).Stop();
1758                 }
1759                 catch (Exception e)
1760                 {
1761                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1762                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1763                 }
1764
1765
1766             }
1767             else
1768             {
1769                 efl_player_stop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1770             }
1771         }
1772
1773         private static efl_player_stop_delegate efl_player_stop_static_delegate;
1774
1775         #pragma warning restore CA1707, SA1300, SA1600
1776
1777 }
1778 }
1779 }
1780
1781 }
1782