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

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