internals/src/EflSharp/EflSharp/efl_file.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.ComponentModel;
   7 namespace Efl {
   8 /// <summary>Efl file interface</summary>
   9 [FileNativeInherit]
  10 public interface File :
  11    Efl.Eo.IWrapper, IDisposable
  12 {
  13    /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
  14 /// <returns>The handle to an Eina_File that will be used</returns>
  15 Eina.File GetMmap();
  16    /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an Eina_File).
  17 /// If mmap is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
  18 /// <param name="f">The handle to an Eina_File that will be used</param>
  19 /// <returns>0 on success, error code otherwise</returns>
  20  Eina.Error SetMmap( Eina.File f);
  21    /// <summary>Retrieve the file path from where an object is to fetch the data.
  22 /// You must not modify the strings on the returned pointers.</summary>
  23 /// <returns>The file path.</returns>
  24  System.String GetFile();
  25    /// <summary>Set the file path from where an object will fetch the data.
  26 /// If file is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
  27 /// <param name="file">The file path.</param>
  28 /// <returns>0 on success, error code otherwise</returns>
  29  Eina.Error SetFile(  System.String file);
  30    /// <summary>Get the previously-set key which corresponds to the target data within a file.
  31 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
  32 ///
  33 /// You must not modify the strings on the returned pointers.</summary>
  34 /// <returns>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</returns>
  35  System.String GetKey();
  36    /// <summary>Set the key which corresponds to the target data within a file.
  37 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.</summary>
  38 /// <param name="key">The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</param>
  39 /// <returns></returns>
  40  void SetKey(  System.String key);
  41    /// <summary>Get the load state of the object.</summary>
  42 /// <returns>True if the object is loaded, otherwise false.</returns>
  43 bool GetLoaded();
  44    /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.File.File"/> (or <see cref="Efl.File.Mmap"/>) and <see cref="Efl.File.Key"/> properties.
  45 /// In the case where <see cref="Efl.File.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.File.SetMmap"/> on the object using the opened file handle.
  46 ///
  47 /// Calling <see cref="Efl.File.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.</summary>
  48 /// <returns>0 on success, error code otherwise</returns>
  49  Eina.Error Load();
  50    /// <summary>Perform all necessary operations to unload file data from the object.
  51 /// In the case where <see cref="Efl.File.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
  52 ///
  53 /// Calling <see cref="Efl.File.Unload"/> on an object which is not currently loaded will have no effect.</summary>
  54 /// <returns></returns>
  55  void Unload();
  56                               /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
  57 /// <value>The handle to an Eina_File that will be used</value>
  58    Eina.File Mmap {
  59       get ;
  60       set ;
  61    }
  62    /// <summary>Retrieve the file path from where an object is to fetch the data.
  63 /// You must not modify the strings on the returned pointers.</summary>
  64 /// <value>The file path.</value>
  65     System.String File {
  66       get ;
  67       set ;
  68    }
  69    /// <summary>Get the previously-set key which corresponds to the target data within a file.
  70 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
  71 ///
  72 /// You must not modify the strings on the returned pointers.</summary>
  73 /// <value>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</value>
  74     System.String Key {
  75       get ;
  76       set ;
  77    }
  78    /// <summary>Get the load state of the object.</summary>
  79 /// <value>True if the object is loaded, otherwise false.</value>
  80    bool Loaded {
  81       get ;
  82    }
  83 }
  84 /// <summary>Efl file interface</summary>
  85 sealed public class FileConcrete :
  86
  87 File
  88
  89 {
  90    ///<summary>Pointer to the native class description.</summary>
  91    public System.IntPtr NativeClass {
  92       get {
  93          if (((object)this).GetType() == typeof (FileConcrete))
  94             return Efl.FileNativeInherit.GetEflClassStatic();
  95          else
  96             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  97       }
  98    }
  99    private  System.IntPtr handle;
 100    ///<summary>Pointer to the native instance.</summary>
 101    public System.IntPtr NativeHandle {
 102       get { return handle; }
 103    }
 104    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 105       efl_file_mixin_get();
 106    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 107    public FileConcrete(System.IntPtr raw)
 108    {
 109       handle = raw;
 110       register_event_proxies();
 111    }
 112    ///<summary>Destructor.</summary>
 113    ~FileConcrete()
 114    {
 115       Dispose(false);
 116    }
 117    ///<summary>Releases the underlying native instance.</summary>
 118    void Dispose(bool disposing)
 119    {
 120       if (handle != System.IntPtr.Zero) {
 121          Efl.Eo.Globals.efl_unref(handle);
 122          handle = System.IntPtr.Zero;
 123       }
 124    }
 125    ///<summary>Releases the underlying native instance.</summary>
 126    public void Dispose()
 127    {
 128       Dispose(true);
 129       GC.SuppressFinalize(this);
 130    }
 131    ///<summary>Casts obj into an instance of this type.</summary>
 132    public static FileConcrete static_cast(Efl.Object obj)
 133    {
 134       if (obj == null)
 135          throw new System.ArgumentNullException("obj");
 136       return new FileConcrete(obj.NativeHandle);
 137    }
 138    ///<summary>Verifies if the given object is equal to this one.</summary>
 139    public override bool Equals(object obj)
 140    {
 141       var other = obj as Efl.Object;
 142       if (other == null)
 143          return false;
 144       return this.NativeHandle == other.NativeHandle;
 145    }
 146    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 147    public override int GetHashCode()
 148    {
 149       return this.NativeHandle.ToInt32();
 150    }
 151    ///<summary>Turns the native pointer into a string representation.</summary>
 152    public override String ToString()
 153    {
 154       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 155    }
 156     void register_event_proxies()
 157    {
 158    }
 159    /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
 160    /// <returns>The handle to an Eina_File that will be used</returns>
 161    public Eina.File GetMmap() {
 162        var _ret_var = Efl.FileNativeInherit.efl_file_mmap_get_ptr.Value.Delegate(this.NativeHandle);
 163       Eina.Error.RaiseIfUnhandledException();
 164       return _ret_var;
 165  }
 166    /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an Eina_File).
 167    /// If mmap is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
 168    /// <param name="f">The handle to an Eina_File that will be used</param>
 169    /// <returns>0 on success, error code otherwise</returns>
 170    public  Eina.Error SetMmap( Eina.File f) {
 171                          var _ret_var = Efl.FileNativeInherit.efl_file_mmap_set_ptr.Value.Delegate(this.NativeHandle, f);
 172       Eina.Error.RaiseIfUnhandledException();
 173                   return _ret_var;
 174  }
 175    /// <summary>Retrieve the file path from where an object is to fetch the data.
 176    /// You must not modify the strings on the returned pointers.</summary>
 177    /// <returns>The file path.</returns>
 178    public  System.String GetFile() {
 179        var _ret_var = Efl.FileNativeInherit.efl_file_get_ptr.Value.Delegate(this.NativeHandle);
 180       Eina.Error.RaiseIfUnhandledException();
 181       return _ret_var;
 182  }
 183    /// <summary>Set the file path from where an object will fetch the data.
 184    /// If file is set during object construction, the object will automatically call <see cref="Efl.File.Load"/> during the finalize phase of construction.</summary>
 185    /// <param name="file">The file path.</param>
 186    /// <returns>0 on success, error code otherwise</returns>
 187    public  Eina.Error SetFile(  System.String file) {
 188                          var _ret_var = Efl.FileNativeInherit.efl_file_set_ptr.Value.Delegate(this.NativeHandle, file);
 189       Eina.Error.RaiseIfUnhandledException();
 190                   return _ret_var;
 191  }
 192    /// <summary>Get the previously-set key which corresponds to the target data within a file.
 193    /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 194    ///
 195    /// You must not modify the strings on the returned pointers.</summary>
 196    /// <returns>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</returns>
 197    public  System.String GetKey() {
 198        var _ret_var = Efl.FileNativeInherit.efl_file_key_get_ptr.Value.Delegate(this.NativeHandle);
 199       Eina.Error.RaiseIfUnhandledException();
 200       return _ret_var;
 201  }
 202    /// <summary>Set the key which corresponds to the target data within a file.
 203    /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.</summary>
 204    /// <param name="key">The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</param>
 205    /// <returns></returns>
 206    public  void SetKey(  System.String key) {
 207                          Efl.FileNativeInherit.efl_file_key_set_ptr.Value.Delegate(this.NativeHandle, key);
 208       Eina.Error.RaiseIfUnhandledException();
 209                    }
 210    /// <summary>Get the load state of the object.</summary>
 211    /// <returns>True if the object is loaded, otherwise false.</returns>
 212    public bool GetLoaded() {
 213        var _ret_var = Efl.FileNativeInherit.efl_file_loaded_get_ptr.Value.Delegate(this.NativeHandle);
 214       Eina.Error.RaiseIfUnhandledException();
 215       return _ret_var;
 216  }
 217    /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.File.File"/> (or <see cref="Efl.File.Mmap"/>) and <see cref="Efl.File.Key"/> properties.
 218    /// In the case where <see cref="Efl.File.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.File.SetMmap"/> on the object using the opened file handle.
 219    ///
 220    /// Calling <see cref="Efl.File.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.</summary>
 221    /// <returns>0 on success, error code otherwise</returns>
 222    public  Eina.Error Load() {
 223        var _ret_var = Efl.FileNativeInherit.efl_file_load_ptr.Value.Delegate(this.NativeHandle);
 224       Eina.Error.RaiseIfUnhandledException();
 225       return _ret_var;
 226  }
 227    /// <summary>Perform all necessary operations to unload file data from the object.
 228    /// In the case where <see cref="Efl.File.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 229    ///
 230    /// Calling <see cref="Efl.File.Unload"/> on an object which is not currently loaded will have no effect.</summary>
 231    /// <returns></returns>
 232    public  void Unload() {
 233        Efl.FileNativeInherit.efl_file_unload_ptr.Value.Delegate(this.NativeHandle);
 234       Eina.Error.RaiseIfUnhandledException();
 235        }
 236    /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an Eina_File).</summary>
 237 /// <value>The handle to an Eina_File that will be used</value>
 238    public Eina.File Mmap {
 239       get { return GetMmap(); }
 240       set { SetMmap( value); }
 241    }
 242    /// <summary>Retrieve the file path from where an object is to fetch the data.
 243 /// You must not modify the strings on the returned pointers.</summary>
 244 /// <value>The file path.</value>
 245    public  System.String File {
 246       get { return GetFile(); }
 247       set { SetFile( value); }
 248    }
 249    /// <summary>Get the previously-set key which corresponds to the target data within a file.
 250 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 251 ///
 252 /// You must not modify the strings on the returned pointers.</summary>
 253 /// <value>The group that the image belongs to, in case  it&apos;s an EET(including Edje case) file. This can be used as a key inside evas image cache if this is a normal image file not eet file.</value>
 254    public  System.String Key {
 255       get { return GetKey(); }
 256       set { SetKey( value); }
 257    }
 258    /// <summary>Get the load state of the object.</summary>
 259 /// <value>True if the object is loaded, otherwise false.</value>
 260    public bool Loaded {
 261       get { return GetLoaded(); }
 262    }
 263 }
 264 public class FileNativeInherit  : Efl.Eo.NativeClass{
 265    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 266    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 267    {
 268       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 269       if (efl_file_mmap_get_static_delegate == null)
 270       efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 271       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)});
 272       if (efl_file_mmap_set_static_delegate == null)
 273       efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 274       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)});
 275       if (efl_file_get_static_delegate == null)
 276       efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 277       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)});
 278       if (efl_file_set_static_delegate == null)
 279       efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 280       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)});
 281       if (efl_file_key_get_static_delegate == null)
 282       efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 283       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)});
 284       if (efl_file_key_set_static_delegate == null)
 285       efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 286       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)});
 287       if (efl_file_loaded_get_static_delegate == null)
 288       efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 289       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)});
 290       if (efl_file_load_static_delegate == null)
 291       efl_file_load_static_delegate = new efl_file_load_delegate(load);
 292       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)});
 293       if (efl_file_unload_static_delegate == null)
 294       efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 295       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)});
 296       return descs;
 297    }
 298    public override IntPtr GetEflClass()
 299    {
 300       return Efl.FileConcrete.efl_file_mixin_get();
 301    }
 302    public static  IntPtr GetEflClassStatic()
 303    {
 304       return Efl.FileConcrete.efl_file_mixin_get();
 305    }
 306
 307
 308     private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 309
 310
 311     public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 312     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");
 313     private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 314    {
 315       Eina.Log.Debug("function efl_file_mmap_get was called");
 316       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 317       if(wrapper != null) {
 318                   Eina.File _ret_var = default(Eina.File);
 319          try {
 320             _ret_var = ((FileConcrete)wrapper).GetMmap();
 321          } catch (Exception e) {
 322             Eina.Log.Warning($"Callback error: {e.ToString()}");
 323             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 324          }
 325       return _ret_var;
 326       } else {
 327          return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 328       }
 329    }
 330    private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 331
 332
 333     private delegate  Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.File f);
 334
 335
 336     public delegate  Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,   Eina.File f);
 337     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");
 338     private static  Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd,  Eina.File f)
 339    {
 340       Eina.Log.Debug("function efl_file_mmap_set was called");
 341       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 342       if(wrapper != null) {
 343                                      Eina.Error _ret_var = default( Eina.Error);
 344          try {
 345             _ret_var = ((FileConcrete)wrapper).SetMmap( f);
 346          } catch (Exception e) {
 347             Eina.Log.Warning($"Callback error: {e.ToString()}");
 348             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 349          }
 350                   return _ret_var;
 351       } else {
 352          return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  f);
 353       }
 354    }
 355    private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 356
 357
 358     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 359
 360
 361     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_file_get_api_delegate(System.IntPtr obj);
 362     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");
 363     private static  System.String file_get(System.IntPtr obj, System.IntPtr pd)
 364    {
 365       Eina.Log.Debug("function efl_file_get was called");
 366       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 367       if(wrapper != null) {
 368                    System.String _ret_var = default( System.String);
 369          try {
 370             _ret_var = ((FileConcrete)wrapper).GetFile();
 371          } catch (Exception e) {
 372             Eina.Log.Warning($"Callback error: {e.ToString()}");
 373             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 374          }
 375       return _ret_var;
 376       } else {
 377          return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 378       }
 379    }
 380    private static efl_file_get_delegate efl_file_get_static_delegate;
 381
 382
 383     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);
 384
 385
 386     public delegate  Eina.Error efl_file_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String file);
 387     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");
 388     private static  Eina.Error file_set(System.IntPtr obj, System.IntPtr pd,   System.String file)
 389    {
 390       Eina.Log.Debug("function efl_file_set was called");
 391       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 392       if(wrapper != null) {
 393                                      Eina.Error _ret_var = default( Eina.Error);
 394          try {
 395             _ret_var = ((FileConcrete)wrapper).SetFile( file);
 396          } catch (Exception e) {
 397             Eina.Log.Warning($"Callback error: {e.ToString()}");
 398             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 399          }
 400                   return _ret_var;
 401       } else {
 402          return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  file);
 403       }
 404    }
 405    private static efl_file_set_delegate efl_file_set_static_delegate;
 406
 407
 408     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
 409
 410
 411     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_file_key_get_api_delegate(System.IntPtr obj);
 412     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");
 413     private static  System.String key_get(System.IntPtr obj, System.IntPtr pd)
 414    {
 415       Eina.Log.Debug("function efl_file_key_get was called");
 416       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 417       if(wrapper != null) {
 418                    System.String _ret_var = default( System.String);
 419          try {
 420             _ret_var = ((FileConcrete)wrapper).GetKey();
 421          } catch (Exception e) {
 422             Eina.Log.Warning($"Callback error: {e.ToString()}");
 423             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 424          }
 425       return _ret_var;
 426       } else {
 427          return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 428       }
 429    }
 430    private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
 431
 432
 433     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);
 434
 435
 436     public delegate  void efl_file_key_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String key);
 437     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");
 438     private static  void key_set(System.IntPtr obj, System.IntPtr pd,   System.String key)
 439    {
 440       Eina.Log.Debug("function efl_file_key_set was called");
 441       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 442       if(wrapper != null) {
 443
 444          try {
 445             ((FileConcrete)wrapper).SetKey( key);
 446          } catch (Exception e) {
 447             Eina.Log.Warning($"Callback error: {e.ToString()}");
 448             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 449          }
 450                         } else {
 451          efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key);
 452       }
 453    }
 454    private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
 455
 456
 457     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
 458
 459
 460     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
 461     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");
 462     private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
 463    {
 464       Eina.Log.Debug("function efl_file_loaded_get was called");
 465       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 466       if(wrapper != null) {
 467                   bool _ret_var = default(bool);
 468          try {
 469             _ret_var = ((FileConcrete)wrapper).GetLoaded();
 470          } catch (Exception e) {
 471             Eina.Log.Warning($"Callback error: {e.ToString()}");
 472             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 473          }
 474       return _ret_var;
 475       } else {
 476          return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 477       }
 478    }
 479    private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
 480
 481
 482     private delegate  Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
 483
 484
 485     public delegate  Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
 486     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");
 487     private static  Eina.Error load(System.IntPtr obj, System.IntPtr pd)
 488    {
 489       Eina.Log.Debug("function efl_file_load was called");
 490       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 491       if(wrapper != null) {
 492                    Eina.Error _ret_var = default( Eina.Error);
 493          try {
 494             _ret_var = ((FileConcrete)wrapper).Load();
 495          } catch (Exception e) {
 496             Eina.Log.Warning($"Callback error: {e.ToString()}");
 497             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 498          }
 499       return _ret_var;
 500       } else {
 501          return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 502       }
 503    }
 504    private static efl_file_load_delegate efl_file_load_static_delegate;
 505
 506
 507     private delegate  void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
 508
 509
 510     public delegate  void efl_file_unload_api_delegate(System.IntPtr obj);
 511     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");
 512     private static  void unload(System.IntPtr obj, System.IntPtr pd)
 513    {
 514       Eina.Log.Debug("function efl_file_unload was called");
 515       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 516       if(wrapper != null) {
 517
 518          try {
 519             ((FileConcrete)wrapper).Unload();
 520          } catch (Exception e) {
 521             Eina.Log.Warning($"Callback error: {e.ToString()}");
 522             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 523          }
 524             } else {
 525          efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 526       }
 527    }
 528    private static efl_file_unload_delegate efl_file_unload_static_delegate;
 529 }
 530 }