internals/src/EflSharp/EflSharp/efl/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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 /// <summary>Efl file interface
  11 /// (Since EFL 1.22)</summary>
  12 [Efl.IFileConcrete.NativeMethods]
  13 [Efl.Eo.BindingEntity]
  14 public interface IFile :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  18 /// (Since EFL 1.22)</summary>
  19 /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
  20 Eina.File GetMmap();
  21     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  22 /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
  23 /// (Since EFL 1.22)</summary>
  24 /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
  25 /// <returns>0 on success, error code otherwise</returns>
  26 Eina.Error SetMmap(Eina.File f);
  27     /// <summary>Retrieve the file path from where an object is to fetch the data.
  28 /// You must not modify the strings on the returned pointers.
  29 /// (Since EFL 1.22)</summary>
  30 /// <returns>The file path.</returns>
  31 System.String GetFile();
  32     /// <summary>Set the file path from where an object will fetch the data.
  33 /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
  34 /// (Since EFL 1.22)</summary>
  35 /// <param name="file">The file path.</param>
  36 /// <returns>0 on success, error code otherwise</returns>
  37 Eina.Error SetFile(System.String file);
  38     /// <summary>Get the previously-set key which corresponds to the target data within a file.
  39 /// 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"/>).
  40 ///
  41 /// You must not modify the strings on the returned pointers.
  42 /// (Since EFL 1.22)</summary>
  43 /// <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>
  44 System.String GetKey();
  45     /// <summary>Set the key which corresponds to the target data within a file.
  46 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
  47 /// (Since EFL 1.22)</summary>
  48 /// <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>
  49 void SetKey(System.String key);
  50     /// <summary>Get the load state of the object.
  51 /// (Since EFL 1.22)</summary>
  52 /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
  53 bool GetLoaded();
  54     /// <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.
  55 /// 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.
  56 ///
  57 /// 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.
  58 /// (Since EFL 1.22)</summary>
  59 /// <returns>0 on success, error code otherwise</returns>
  60 Eina.Error Load();
  61     /// <summary>Perform all necessary operations to unload file data from the object.
  62 /// 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.
  63 ///
  64 /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
  65 /// (Since EFL 1.22)</summary>
  66 void Unload();
  67                                         /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  68     /// (Since EFL 1.22)</summary>
  69     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
  70     Eina.File Mmap {
  71         get ;
  72         set ;
  73     }
  74     /// <summary>Retrieve the file path from where an object is to fetch the data.
  75     /// You must not modify the strings on the returned pointers.
  76     /// (Since EFL 1.22)</summary>
  77     /// <value>The file path.</value>
  78     System.String File {
  79         get ;
  80         set ;
  81     }
  82     /// <summary>Get the previously-set key which corresponds to the target data within a file.
  83     /// 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"/>).
  84     ///
  85     /// You must not modify the strings on the returned pointers.
  86     /// (Since EFL 1.22)</summary>
  87     /// <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>
  88     System.String Key {
  89         get ;
  90         set ;
  91     }
  92     /// <summary>Get the load state of the object.
  93     /// (Since EFL 1.22)</summary>
  94     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
  95     bool Loaded {
  96         get ;
  97     }
  98 }
  99 /// <summary>Efl file interface
 100 /// (Since EFL 1.22)</summary>
 101 sealed public class IFileConcrete :
 102     Efl.Eo.EoWrapper
 103     , IFile
 104
 105 {
 106     ///<summary>Pointer to the native class description.</summary>
 107     public override System.IntPtr NativeClass
 108     {
 109         get
 110         {
 111             if (((object)this).GetType() == typeof(IFileConcrete))
 112             {
 113                 return GetEflClassStatic();
 114             }
 115             else
 116             {
 117                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 118             }
 119         }
 120     }
 121
 122     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 123     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 124     private IFileConcrete(ConstructingHandle ch) : base(ch)
 125     {
 126     }
 127
 128     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 129         efl_file_mixin_get();
 130     /// <summary>Initializes a new instance of the <see cref="IFile"/> class.
 131     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 132     /// <param name="wh">The native pointer to be wrapped.</param>
 133     private IFileConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 134     {
 135     }
 136
 137     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 138     /// (Since EFL 1.22)</summary>
 139     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 140     public Eina.File GetMmap() {
 141          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate(this.NativeHandle);
 142         Eina.Error.RaiseIfUnhandledException();
 143         return _ret_var;
 144  }
 145     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 146     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 147     /// (Since EFL 1.22)</summary>
 148     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 149     /// <returns>0 on success, error code otherwise</returns>
 150     public Eina.Error SetMmap(Eina.File f) {
 151                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate(this.NativeHandle,f);
 152         Eina.Error.RaiseIfUnhandledException();
 153                         return _ret_var;
 154  }
 155     /// <summary>Retrieve the file path from where an object is to fetch the data.
 156     /// You must not modify the strings on the returned pointers.
 157     /// (Since EFL 1.22)</summary>
 158     /// <returns>The file path.</returns>
 159     public System.String GetFile() {
 160          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate(this.NativeHandle);
 161         Eina.Error.RaiseIfUnhandledException();
 162         return _ret_var;
 163  }
 164     /// <summary>Set the file path from where an object will fetch the data.
 165     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 166     /// (Since EFL 1.22)</summary>
 167     /// <param name="file">The file path.</param>
 168     /// <returns>0 on success, error code otherwise</returns>
 169     public Eina.Error SetFile(System.String file) {
 170                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate(this.NativeHandle,file);
 171         Eina.Error.RaiseIfUnhandledException();
 172                         return _ret_var;
 173  }
 174     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 175     /// 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"/>).
 176     ///
 177     /// You must not modify the strings on the returned pointers.
 178     /// (Since EFL 1.22)</summary>
 179     /// <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>
 180     public System.String GetKey() {
 181          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate(this.NativeHandle);
 182         Eina.Error.RaiseIfUnhandledException();
 183         return _ret_var;
 184  }
 185     /// <summary>Set the key which corresponds to the target data within a file.
 186     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 187     /// (Since EFL 1.22)</summary>
 188     /// <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>
 189     public void SetKey(System.String key) {
 190                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate(this.NativeHandle,key);
 191         Eina.Error.RaiseIfUnhandledException();
 192                          }
 193     /// <summary>Get the load state of the object.
 194     /// (Since EFL 1.22)</summary>
 195     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 196     public bool GetLoaded() {
 197          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate(this.NativeHandle);
 198         Eina.Error.RaiseIfUnhandledException();
 199         return _ret_var;
 200  }
 201     /// <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.
 202     /// 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.
 203     ///
 204     /// 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.
 205     /// (Since EFL 1.22)</summary>
 206     /// <returns>0 on success, error code otherwise</returns>
 207     public Eina.Error Load() {
 208          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate(this.NativeHandle);
 209         Eina.Error.RaiseIfUnhandledException();
 210         return _ret_var;
 211  }
 212     /// <summary>Perform all necessary operations to unload file data from the object.
 213     /// 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.
 214     ///
 215     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 216     /// (Since EFL 1.22)</summary>
 217     public void Unload() {
 218          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate(this.NativeHandle);
 219         Eina.Error.RaiseIfUnhandledException();
 220          }
 221     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 222     /// (Since EFL 1.22)</summary>
 223     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 224     public Eina.File Mmap {
 225         get { return GetMmap(); }
 226         set { SetMmap(value); }
 227     }
 228     /// <summary>Retrieve the file path from where an object is to fetch the data.
 229     /// You must not modify the strings on the returned pointers.
 230     /// (Since EFL 1.22)</summary>
 231     /// <value>The file path.</value>
 232     public System.String File {
 233         get { return GetFile(); }
 234         set { SetFile(value); }
 235     }
 236     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 237     /// 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"/>).
 238     ///
 239     /// You must not modify the strings on the returned pointers.
 240     /// (Since EFL 1.22)</summary>
 241     /// <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>
 242     public System.String Key {
 243         get { return GetKey(); }
 244         set { SetKey(value); }
 245     }
 246     /// <summary>Get the load state of the object.
 247     /// (Since EFL 1.22)</summary>
 248     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 249     public bool Loaded {
 250         get { return GetLoaded(); }
 251     }
 252     private static IntPtr GetEflClassStatic()
 253     {
 254         return Efl.IFileConcrete.efl_file_mixin_get();
 255     }
 256     /// <summary>Wrapper for native methods and virtual method delegates.
 257     /// For internal use by generated code only.</summary>
 258     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 259     {
 260         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 261         /// <summary>Gets the list of Eo operations to override.</summary>
 262         /// <returns>The list of Eo operations to be overload.</returns>
 263         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 264         {
 265             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 266             var methods = Efl.Eo.Globals.GetUserMethods(type);
 267
 268             if (efl_file_mmap_get_static_delegate == null)
 269             {
 270                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 271             }
 272
 273             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 274             {
 275                 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) });
 276             }
 277
 278             if (efl_file_mmap_set_static_delegate == null)
 279             {
 280                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 281             }
 282
 283             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 284             {
 285                 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) });
 286             }
 287
 288             if (efl_file_get_static_delegate == null)
 289             {
 290                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 291             }
 292
 293             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 294             {
 295                 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) });
 296             }
 297
 298             if (efl_file_set_static_delegate == null)
 299             {
 300                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 301             }
 302
 303             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 304             {
 305                 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) });
 306             }
 307
 308             if (efl_file_key_get_static_delegate == null)
 309             {
 310                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 311             }
 312
 313             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 314             {
 315                 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) });
 316             }
 317
 318             if (efl_file_key_set_static_delegate == null)
 319             {
 320                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 321             }
 322
 323             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 324             {
 325                 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) });
 326             }
 327
 328             if (efl_file_loaded_get_static_delegate == null)
 329             {
 330                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 331             }
 332
 333             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 334             {
 335                 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) });
 336             }
 337
 338             if (efl_file_load_static_delegate == null)
 339             {
 340                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 341             }
 342
 343             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 344             {
 345                 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) });
 346             }
 347
 348             if (efl_file_unload_static_delegate == null)
 349             {
 350                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 351             }
 352
 353             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 354             {
 355                 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) });
 356             }
 357
 358             return descs;
 359         }
 360         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 361         /// <returns>The native class pointer.</returns>
 362         public override IntPtr GetEflClass()
 363         {
 364             return Efl.IFileConcrete.efl_file_mixin_get();
 365         }
 366
 367         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 368
 369
 370         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 371
 372
 373         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 374
 375         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");
 376
 377         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 378         {
 379             Eina.Log.Debug("function efl_file_mmap_get was called");
 380             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 381             if (ws != null)
 382             {
 383             Eina.File _ret_var = default(Eina.File);
 384                 try
 385                 {
 386                     _ret_var = ((IFile)ws.Target).GetMmap();
 387                 }
 388                 catch (Exception e)
 389                 {
 390                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 391                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 392                 }
 393
 394         return _ret_var;
 395
 396             }
 397             else
 398             {
 399                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 400             }
 401         }
 402
 403         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 404
 405
 406         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
 407
 408
 409         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
 410
 411         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");
 412
 413         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
 414         {
 415             Eina.Log.Debug("function efl_file_mmap_set was called");
 416             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 417             if (ws != null)
 418             {
 419                                     Eina.Error _ret_var = default(Eina.Error);
 420                 try
 421                 {
 422                     _ret_var = ((IFile)ws.Target).SetMmap(f);
 423                 }
 424                 catch (Exception e)
 425                 {
 426                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 427                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 428                 }
 429
 430                         return _ret_var;
 431
 432             }
 433             else
 434             {
 435                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 436             }
 437         }
 438
 439         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 440
 441         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 442         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 443
 444         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 445         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
 446
 447         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");
 448
 449         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
 450         {
 451             Eina.Log.Debug("function efl_file_get was called");
 452             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 453             if (ws != null)
 454             {
 455             System.String _ret_var = default(System.String);
 456                 try
 457                 {
 458                     _ret_var = ((IFile)ws.Target).GetFile();
 459                 }
 460                 catch (Exception e)
 461                 {
 462                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 463                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 464                 }
 465
 466         return _ret_var;
 467
 468             }
 469             else
 470             {
 471                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 472             }
 473         }
 474
 475         private static efl_file_get_delegate efl_file_get_static_delegate;
 476
 477
 478         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);
 479
 480
 481         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
 482
 483         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");
 484
 485         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
 486         {
 487             Eina.Log.Debug("function efl_file_set was called");
 488             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 489             if (ws != null)
 490             {
 491                                     Eina.Error _ret_var = default(Eina.Error);
 492                 try
 493                 {
 494                     _ret_var = ((IFile)ws.Target).SetFile(file);
 495                 }
 496                 catch (Exception e)
 497                 {
 498                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 499                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 500                 }
 501
 502                         return _ret_var;
 503
 504             }
 505             else
 506             {
 507                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
 508             }
 509         }
 510
 511         private static efl_file_set_delegate efl_file_set_static_delegate;
 512
 513         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 514         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
 515
 516         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 517         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
 518
 519         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");
 520
 521         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
 522         {
 523             Eina.Log.Debug("function efl_file_key_get was called");
 524             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 525             if (ws != null)
 526             {
 527             System.String _ret_var = default(System.String);
 528                 try
 529                 {
 530                     _ret_var = ((IFile)ws.Target).GetKey();
 531                 }
 532                 catch (Exception e)
 533                 {
 534                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 535                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 536                 }
 537
 538         return _ret_var;
 539
 540             }
 541             else
 542             {
 543                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 544             }
 545         }
 546
 547         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
 548
 549
 550         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);
 551
 552
 553         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
 554
 555         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");
 556
 557         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
 558         {
 559             Eina.Log.Debug("function efl_file_key_set was called");
 560             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 561             if (ws != null)
 562             {
 563
 564                 try
 565                 {
 566                     ((IFile)ws.Target).SetKey(key);
 567                 }
 568                 catch (Exception e)
 569                 {
 570                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 571                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 572                 }
 573
 574
 575             }
 576             else
 577             {
 578                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
 579             }
 580         }
 581
 582         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
 583
 584         [return: MarshalAs(UnmanagedType.U1)]
 585         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
 586
 587         [return: MarshalAs(UnmanagedType.U1)]
 588         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
 589
 590         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");
 591
 592         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
 593         {
 594             Eina.Log.Debug("function efl_file_loaded_get was called");
 595             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 596             if (ws != null)
 597             {
 598             bool _ret_var = default(bool);
 599                 try
 600                 {
 601                     _ret_var = ((IFile)ws.Target).GetLoaded();
 602                 }
 603                 catch (Exception e)
 604                 {
 605                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 606                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 607                 }
 608
 609         return _ret_var;
 610
 611             }
 612             else
 613             {
 614                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 615             }
 616         }
 617
 618         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
 619
 620
 621         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
 622
 623
 624         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
 625
 626         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");
 627
 628         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
 629         {
 630             Eina.Log.Debug("function efl_file_load was called");
 631             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 632             if (ws != null)
 633             {
 634             Eina.Error _ret_var = default(Eina.Error);
 635                 try
 636                 {
 637                     _ret_var = ((IFile)ws.Target).Load();
 638                 }
 639                 catch (Exception e)
 640                 {
 641                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 642                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 643                 }
 644
 645         return _ret_var;
 646
 647             }
 648             else
 649             {
 650                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 651             }
 652         }
 653
 654         private static efl_file_load_delegate efl_file_load_static_delegate;
 655
 656
 657         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
 658
 659
 660         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
 661
 662         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");
 663
 664         private static void unload(System.IntPtr obj, System.IntPtr pd)
 665         {
 666             Eina.Log.Debug("function efl_file_unload was called");
 667             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 668             if (ws != null)
 669             {
 670
 671                 try
 672                 {
 673                     ((IFile)ws.Target).Unload();
 674                 }
 675                 catch (Exception e)
 676                 {
 677                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 678                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 679                 }
 680
 681
 682             }
 683             else
 684             {
 685                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 686             }
 687         }
 688
 689         private static efl_file_unload_delegate efl_file_unload_static_delegate;
 690
 691         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 692
 693 }
 694 }
 695 }
 696