internals/src/EflSharp/EflSharp/efl/efl_config_global.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>This class is a singleton representing the global configuration for the running application.</summary>
  11 [Efl.ConfigGlobal.NativeMethods]
  12 public class ConfigGlobal : Efl.Object, Efl.Eo.IWrapper,Efl.IConfig
  13 {
  14     ///<summary>Pointer to the native class description.</summary>
  15     public override System.IntPtr NativeClass
  16     {
  17         get
  18         {
  19             if (((object)this).GetType() == typeof(ConfigGlobal))
  20             {
  21                 return GetEflClassStatic();
  22             }
  23             else
  24             {
  25                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  26             }
  27         }
  28     }
  29
  30     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  31         efl_config_global_class_get();
  32     /// <summary>Initializes a new instance of the <see cref="ConfigGlobal"/> class.</summary>
  33     /// <param name="parent">Parent instance.</param>
  34     public ConfigGlobal(Efl.Object parent= null
  35             ) : base(efl_config_global_class_get(), typeof(ConfigGlobal), parent)
  36     {
  37         FinishInstantiation();
  38     }
  39
  40     /// <summary>Initializes a new instance of the <see cref="ConfigGlobal"/> class.
  41     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  42     /// <param name="raw">The native pointer to be wrapped.</param>
  43     protected ConfigGlobal(System.IntPtr raw) : base(raw)
  44     {
  45             }
  46
  47     /// <summary>Initializes a new instance of the <see cref="ConfigGlobal"/> class.
  48     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  49     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  50     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  51     /// <param name="parent">The Efl.Object parent of this instance.</param>
  52     protected ConfigGlobal(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  53     {
  54     }
  55
  56     /// <summary>Verifies if the given object is equal to this one.</summary>
  57     /// <param name="instance">The object to compare to.</param>
  58     /// <returns>True if both objects point to the same native object.</returns>
  59     public override bool Equals(object instance)
  60     {
  61         var other = instance as Efl.Object;
  62         if (other == null)
  63         {
  64             return false;
  65         }
  66         return this.NativeHandle == other.NativeHandle;
  67     }
  68
  69     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  70     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  71     public override int GetHashCode()
  72     {
  73         return this.NativeHandle.ToInt32();
  74     }
  75
  76     /// <summary>Turns the native pointer into a string representation.</summary>
  77     /// <returns>A string with the type and the native pointer for this object.</returns>
  78     public override String ToString()
  79     {
  80         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  81     }
  82
  83     /// <summary>The profile for the running application.
  84     /// Profiles are pre-set options that affect the whole look-and-feel of Elementary-based applications. There are, for example, profiles aimed at desktop computer applications and others aimed at mobile, touchscreen-based ones. You most probably don&apos;t want to use the functions in this group unless you&apos;re writing an elementary configuration manager.
  85     ///
  86     /// This gets or sets the global profile that is applied to all Elementary applications.</summary>
  87     /// <returns>Profile name</returns>
  88     virtual public System.String GetProfile() {
  89          var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_profile_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  90         Eina.Error.RaiseIfUnhandledException();
  91         return _ret_var;
  92  }
  93     /// <summary>The profile for the running application.
  94     /// Profiles are pre-set options that affect the whole look-and-feel of Elementary-based applications. There are, for example, profiles aimed at desktop computer applications and others aimed at mobile, touchscreen-based ones. You most probably don&apos;t want to use the functions in this group unless you&apos;re writing an elementary configuration manager.
  95     ///
  96     /// This gets or sets the global profile that is applied to all Elementary applications.</summary>
  97     /// <param name="profile">Profile name</param>
  98     virtual public void SetProfile(System.String profile) {
  99                                  Efl.ConfigGlobal.NativeMethods.efl_config_profile_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
 100         Eina.Error.RaiseIfUnhandledException();
 101                          }
 102     /// <summary>Saves Elementary configuration to disk.
 103     /// This function will take effect (does I/O) immediately. Use it when you want to save all configuration changes at once. The current configuration set will get saved onto the current profile configuration file.
 104     ///
 105     /// If <c>profile</c> is <c>null</c>, this will flush all settings to all applications running on the same profile.
 106     ///
 107     /// If <c>profile</c> is not <c>null</c>, this will take the current in-memory config and write it out to the named <c>profile</c>. This will not change profile for the application or make other processes switch profile.</summary>
 108     /// <param name="profile">The profile name.</param>
 109     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 110     virtual public bool Save(System.String profile) {
 111                                  var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_save_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
 112         Eina.Error.RaiseIfUnhandledException();
 113                         return _ret_var;
 114  }
 115     /// <summary>Returns the list of available profiles.</summary>
 116     /// <param name="hidden">If <c>true</c>, gets the full list of profiles, including those stored in hidden files.</param>
 117     /// <returns>Iterator to profiles</returns>
 118     virtual public Eina.Iterator<System.String> ProfileIterate(bool hidden) {
 119                                  var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_profile_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),hidden);
 120         Eina.Error.RaiseIfUnhandledException();
 121                         return new Eina.Iterator<System.String>(_ret_var, true, false);
 122  }
 123     /// <summary>Returns whether a profile exists or not.</summary>
 124     /// <param name="profile">Profile name</param>
 125     /// <returns><c>true</c> if profile exists, <c>false</c> otherwise</returns>
 126     virtual public bool ProfileExists(System.String profile) {
 127                                  var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_profile_exists_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
 128         Eina.Error.RaiseIfUnhandledException();
 129                         return _ret_var;
 130  }
 131     /// <summary>Returns the directory where a profile is stored.</summary>
 132     /// <param name="profile">Profile name</param>
 133     /// <param name="is_user"><c>true</c> to lookup for a user profile or <c>false</c> for a system one.</param>
 134     /// <returns>Directory of the profile, free after use.</returns>
 135     virtual public System.String GetProfileDir(System.String profile, bool is_user) {
 136                                                          var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_profile_dir_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile, is_user);
 137         Eina.Error.RaiseIfUnhandledException();
 138                                         return _ret_var;
 139  }
 140     /// <summary>Add a new profile of the given name to be derived from the current profile.
 141     /// This creates a new profile of name <c>profile</c> that will be derived from the currently used profile using the modification commands encoded in the <c>options</c> string.
 142     ///
 143     /// At this point it is not expected that anyone would generally use this API except if you are a desktop environment and so the user base of this API will be enlightenment itself.</summary>
 144     /// <param name="profile">The new profile&apos;s name.</param>
 145     /// <param name="options">Derive options detailing how to modify.</param>
 146     virtual public void AddProfileDerived(System.String profile, System.String options) {
 147                                                          Efl.ConfigGlobal.NativeMethods.efl_config_profile_derived_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile, options);
 148         Eina.Error.RaiseIfUnhandledException();
 149                                          }
 150     /// <summary>Deletes a profile that is derived from the current one.
 151     /// This deletes a derived profile added by <see cref="Efl.ConfigGlobal.AddProfileDerived"/>. This will delete the profile of the given name <c>profile</c> that is derived from the current profile.
 152     ///
 153     /// At this point it is not expected that anyone would generally use this API except if you are a desktop environment and so the user base of this API will be enlightenment itself.</summary>
 154     /// <param name="profile">The name of the profile that is to be deleted.</param>
 155     virtual public void DelProfileDerived(System.String profile) {
 156                                  Efl.ConfigGlobal.NativeMethods.efl_config_profile_derived_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
 157         Eina.Error.RaiseIfUnhandledException();
 158                          }
 159     /// <summary>A generic configuration value, referred to by name.</summary>
 160     /// <param name="name">Configuration option name.</param>
 161     /// <returns>The value. It will be empty if it doesn&apos;t exist. The caller must free it after use (using <c>eina_value_free</c>() in C).</returns>
 162     virtual public Eina.Value GetConfig(System.String name) {
 163                                  var _ret_var = Efl.IConfigConcrete.NativeMethods.efl_config_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),name);
 164         Eina.Error.RaiseIfUnhandledException();
 165                         return _ret_var;
 166  }
 167     /// <summary>A generic configuration value, referred to by name.</summary>
 168     /// <param name="name">Configuration option name.</param>
 169     /// <param name="value">Configuration option value. May be <c>null</c> if not found.</param>
 170     /// <returns><c>false</c> in case of error: value type was invalid, the config can&apos;t be changed, config does not exist...</returns>
 171     virtual public bool SetConfig(System.String name, Eina.Value value) {
 172                                                          var _ret_var = Efl.IConfigConcrete.NativeMethods.efl_config_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),name, value);
 173         Eina.Error.RaiseIfUnhandledException();
 174                                         return _ret_var;
 175  }
 176     /// <summary>The profile for the running application.
 177 /// Profiles are pre-set options that affect the whole look-and-feel of Elementary-based applications. There are, for example, profiles aimed at desktop computer applications and others aimed at mobile, touchscreen-based ones. You most probably don&apos;t want to use the functions in this group unless you&apos;re writing an elementary configuration manager.
 178 ///
 179 /// This gets or sets the global profile that is applied to all Elementary applications.</summary>
 180 /// <value>Profile name</value>
 181     public System.String Profile {
 182         get { return GetProfile(); }
 183         set { SetProfile(value); }
 184     }
 185     private static IntPtr GetEflClassStatic()
 186     {
 187         return Efl.ConfigGlobal.efl_config_global_class_get();
 188     }
 189     /// <summary>Wrapper for native methods and virtual method delegates.
 190     /// For internal use by generated code only.</summary>
 191     public new class NativeMethods : Efl.Object.NativeMethods
 192     {
 193         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 194         /// <summary>Gets the list of Eo operations to override.</summary>
 195         /// <returns>The list of Eo operations to be overload.</returns>
 196         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 197         {
 198             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 199             var methods = Efl.Eo.Globals.GetUserMethods(type);
 200
 201             if (efl_config_profile_get_static_delegate == null)
 202             {
 203                 efl_config_profile_get_static_delegate = new efl_config_profile_get_delegate(profile_get);
 204             }
 205
 206             if (methods.FirstOrDefault(m => m.Name == "GetProfile") != null)
 207             {
 208                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_get"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_get_static_delegate) });
 209             }
 210
 211             if (efl_config_profile_set_static_delegate == null)
 212             {
 213                 efl_config_profile_set_static_delegate = new efl_config_profile_set_delegate(profile_set);
 214             }
 215
 216             if (methods.FirstOrDefault(m => m.Name == "SetProfile") != null)
 217             {
 218                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_set"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_set_static_delegate) });
 219             }
 220
 221             if (efl_config_save_static_delegate == null)
 222             {
 223                 efl_config_save_static_delegate = new efl_config_save_delegate(save);
 224             }
 225
 226             if (methods.FirstOrDefault(m => m.Name == "Save") != null)
 227             {
 228                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_save"), func = Marshal.GetFunctionPointerForDelegate(efl_config_save_static_delegate) });
 229             }
 230
 231             if (efl_config_profile_iterate_static_delegate == null)
 232             {
 233                 efl_config_profile_iterate_static_delegate = new efl_config_profile_iterate_delegate(profile_iterate);
 234             }
 235
 236             if (methods.FirstOrDefault(m => m.Name == "ProfileIterate") != null)
 237             {
 238                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_iterate_static_delegate) });
 239             }
 240
 241             if (efl_config_profile_exists_static_delegate == null)
 242             {
 243                 efl_config_profile_exists_static_delegate = new efl_config_profile_exists_delegate(profile_exists);
 244             }
 245
 246             if (methods.FirstOrDefault(m => m.Name == "ProfileExists") != null)
 247             {
 248                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_exists"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_exists_static_delegate) });
 249             }
 250
 251             if (efl_config_profile_dir_get_static_delegate == null)
 252             {
 253                 efl_config_profile_dir_get_static_delegate = new efl_config_profile_dir_get_delegate(profile_dir_get);
 254             }
 255
 256             if (methods.FirstOrDefault(m => m.Name == "GetProfileDir") != null)
 257             {
 258                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_dir_get"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_dir_get_static_delegate) });
 259             }
 260
 261             if (efl_config_profile_derived_add_static_delegate == null)
 262             {
 263                 efl_config_profile_derived_add_static_delegate = new efl_config_profile_derived_add_delegate(profile_derived_add);
 264             }
 265
 266             if (methods.FirstOrDefault(m => m.Name == "AddProfileDerived") != null)
 267             {
 268                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_derived_add"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_derived_add_static_delegate) });
 269             }
 270
 271             if (efl_config_profile_derived_del_static_delegate == null)
 272             {
 273                 efl_config_profile_derived_del_static_delegate = new efl_config_profile_derived_del_delegate(profile_derived_del);
 274             }
 275
 276             if (methods.FirstOrDefault(m => m.Name == "DelProfileDerived") != null)
 277             {
 278                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_profile_derived_del"), func = Marshal.GetFunctionPointerForDelegate(efl_config_profile_derived_del_static_delegate) });
 279             }
 280
 281             if (efl_config_get_static_delegate == null)
 282             {
 283                 efl_config_get_static_delegate = new efl_config_get_delegate(config_get);
 284             }
 285
 286             if (methods.FirstOrDefault(m => m.Name == "GetConfig") != null)
 287             {
 288                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_get"), func = Marshal.GetFunctionPointerForDelegate(efl_config_get_static_delegate) });
 289             }
 290
 291             if (efl_config_set_static_delegate == null)
 292             {
 293                 efl_config_set_static_delegate = new efl_config_set_delegate(config_set);
 294             }
 295
 296             if (methods.FirstOrDefault(m => m.Name == "SetConfig") != null)
 297             {
 298                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_config_set"), func = Marshal.GetFunctionPointerForDelegate(efl_config_set_static_delegate) });
 299             }
 300
 301             descs.AddRange(base.GetEoOps(type));
 302             return descs;
 303         }
 304         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 305         /// <returns>The native class pointer.</returns>
 306         public override IntPtr GetEflClass()
 307         {
 308             return Efl.ConfigGlobal.efl_config_global_class_get();
 309         }
 310
 311         #pragma warning disable CA1707, SA1300, SA1600
 312
 313         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 314         private delegate System.String efl_config_profile_get_delegate(System.IntPtr obj, System.IntPtr pd);
 315
 316         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 317         public delegate System.String efl_config_profile_get_api_delegate(System.IntPtr obj);
 318
 319         public static Efl.Eo.FunctionWrapper<efl_config_profile_get_api_delegate> efl_config_profile_get_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_get_api_delegate>(Module, "efl_config_profile_get");
 320
 321         private static System.String profile_get(System.IntPtr obj, System.IntPtr pd)
 322         {
 323             Eina.Log.Debug("function efl_config_profile_get was called");
 324             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 325             if (wrapper != null)
 326             {
 327             System.String _ret_var = default(System.String);
 328                 try
 329                 {
 330                     _ret_var = ((ConfigGlobal)wrapper).GetProfile();
 331                 }
 332                 catch (Exception e)
 333                 {
 334                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 335                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 336                 }
 337
 338         return _ret_var;
 339
 340             }
 341             else
 342             {
 343                 return efl_config_profile_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 344             }
 345         }
 346
 347         private static efl_config_profile_get_delegate efl_config_profile_get_static_delegate;
 348
 349
 350         private delegate void efl_config_profile_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 351
 352
 353         public delegate void efl_config_profile_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 354
 355         public static Efl.Eo.FunctionWrapper<efl_config_profile_set_api_delegate> efl_config_profile_set_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_set_api_delegate>(Module, "efl_config_profile_set");
 356
 357         private static void profile_set(System.IntPtr obj, System.IntPtr pd, System.String profile)
 358         {
 359             Eina.Log.Debug("function efl_config_profile_set was called");
 360             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 361             if (wrapper != null)
 362             {
 363
 364                 try
 365                 {
 366                     ((ConfigGlobal)wrapper).SetProfile(profile);
 367                 }
 368                 catch (Exception e)
 369                 {
 370                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 371                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 372                 }
 373
 374
 375             }
 376             else
 377             {
 378                 efl_config_profile_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile);
 379             }
 380         }
 381
 382         private static efl_config_profile_set_delegate efl_config_profile_set_static_delegate;
 383
 384         [return: MarshalAs(UnmanagedType.U1)]
 385         private delegate bool efl_config_save_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 386
 387         [return: MarshalAs(UnmanagedType.U1)]
 388         public delegate bool efl_config_save_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 389
 390         public static Efl.Eo.FunctionWrapper<efl_config_save_api_delegate> efl_config_save_ptr = new Efl.Eo.FunctionWrapper<efl_config_save_api_delegate>(Module, "efl_config_save");
 391
 392         private static bool save(System.IntPtr obj, System.IntPtr pd, System.String profile)
 393         {
 394             Eina.Log.Debug("function efl_config_save was called");
 395             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 396             if (wrapper != null)
 397             {
 398                                     bool _ret_var = default(bool);
 399                 try
 400                 {
 401                     _ret_var = ((ConfigGlobal)wrapper).Save(profile);
 402                 }
 403                 catch (Exception e)
 404                 {
 405                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 406                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 407                 }
 408
 409                         return _ret_var;
 410
 411             }
 412             else
 413             {
 414                 return efl_config_save_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile);
 415             }
 416         }
 417
 418         private static efl_config_save_delegate efl_config_save_static_delegate;
 419
 420
 421         private delegate System.IntPtr efl_config_profile_iterate_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool hidden);
 422
 423
 424         public delegate System.IntPtr efl_config_profile_iterate_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool hidden);
 425
 426         public static Efl.Eo.FunctionWrapper<efl_config_profile_iterate_api_delegate> efl_config_profile_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_iterate_api_delegate>(Module, "efl_config_profile_iterate");
 427
 428         private static System.IntPtr profile_iterate(System.IntPtr obj, System.IntPtr pd, bool hidden)
 429         {
 430             Eina.Log.Debug("function efl_config_profile_iterate was called");
 431             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 432             if (wrapper != null)
 433             {
 434                                     Eina.Iterator<System.String> _ret_var = default(Eina.Iterator<System.String>);
 435                 try
 436                 {
 437                     _ret_var = ((ConfigGlobal)wrapper).ProfileIterate(hidden);
 438                 }
 439                 catch (Exception e)
 440                 {
 441                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 442                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 443                 }
 444
 445                         _ret_var.Own = false; return _ret_var.Handle;
 446
 447             }
 448             else
 449             {
 450                 return efl_config_profile_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hidden);
 451             }
 452         }
 453
 454         private static efl_config_profile_iterate_delegate efl_config_profile_iterate_static_delegate;
 455
 456         [return: MarshalAs(UnmanagedType.U1)]
 457         private delegate bool efl_config_profile_exists_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 458
 459         [return: MarshalAs(UnmanagedType.U1)]
 460         public delegate bool efl_config_profile_exists_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 461
 462         public static Efl.Eo.FunctionWrapper<efl_config_profile_exists_api_delegate> efl_config_profile_exists_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_exists_api_delegate>(Module, "efl_config_profile_exists");
 463
 464         private static bool profile_exists(System.IntPtr obj, System.IntPtr pd, System.String profile)
 465         {
 466             Eina.Log.Debug("function efl_config_profile_exists was called");
 467             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 468             if (wrapper != null)
 469             {
 470                                     bool _ret_var = default(bool);
 471                 try
 472                 {
 473                     _ret_var = ((ConfigGlobal)wrapper).ProfileExists(profile);
 474                 }
 475                 catch (Exception e)
 476                 {
 477                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 478                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 479                 }
 480
 481                         return _ret_var;
 482
 483             }
 484             else
 485             {
 486                 return efl_config_profile_exists_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile);
 487             }
 488         }
 489
 490         private static efl_config_profile_exists_delegate efl_config_profile_exists_static_delegate;
 491
 492         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]
 493         private delegate System.String efl_config_profile_dir_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile, [MarshalAs(UnmanagedType.U1)] bool is_user);
 494
 495         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]
 496         public delegate System.String efl_config_profile_dir_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile, [MarshalAs(UnmanagedType.U1)] bool is_user);
 497
 498         public static Efl.Eo.FunctionWrapper<efl_config_profile_dir_get_api_delegate> efl_config_profile_dir_get_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_dir_get_api_delegate>(Module, "efl_config_profile_dir_get");
 499
 500         private static System.String profile_dir_get(System.IntPtr obj, System.IntPtr pd, System.String profile, bool is_user)
 501         {
 502             Eina.Log.Debug("function efl_config_profile_dir_get was called");
 503             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 504             if (wrapper != null)
 505             {
 506                                                             System.String _ret_var = default(System.String);
 507                 try
 508                 {
 509                     _ret_var = ((ConfigGlobal)wrapper).GetProfileDir(profile, is_user);
 510                 }
 511                 catch (Exception e)
 512                 {
 513                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 514                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 515                 }
 516
 517                                         return _ret_var;
 518
 519             }
 520             else
 521             {
 522                 return efl_config_profile_dir_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile, is_user);
 523             }
 524         }
 525
 526         private static efl_config_profile_dir_get_delegate efl_config_profile_dir_get_static_delegate;
 527
 528
 529         private delegate void efl_config_profile_derived_add_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String options);
 530
 531
 532         public delegate void efl_config_profile_derived_add_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String options);
 533
 534         public static Efl.Eo.FunctionWrapper<efl_config_profile_derived_add_api_delegate> efl_config_profile_derived_add_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_derived_add_api_delegate>(Module, "efl_config_profile_derived_add");
 535
 536         private static void profile_derived_add(System.IntPtr obj, System.IntPtr pd, System.String profile, System.String options)
 537         {
 538             Eina.Log.Debug("function efl_config_profile_derived_add was called");
 539             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 540             if (wrapper != null)
 541             {
 542
 543                 try
 544                 {
 545                     ((ConfigGlobal)wrapper).AddProfileDerived(profile, options);
 546                 }
 547                 catch (Exception e)
 548                 {
 549                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 550                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 551                 }
 552
 553
 554             }
 555             else
 556             {
 557                 efl_config_profile_derived_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile, options);
 558             }
 559         }
 560
 561         private static efl_config_profile_derived_add_delegate efl_config_profile_derived_add_static_delegate;
 562
 563
 564         private delegate void efl_config_profile_derived_del_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 565
 566
 567         public delegate void efl_config_profile_derived_del_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String profile);
 568
 569         public static Efl.Eo.FunctionWrapper<efl_config_profile_derived_del_api_delegate> efl_config_profile_derived_del_ptr = new Efl.Eo.FunctionWrapper<efl_config_profile_derived_del_api_delegate>(Module, "efl_config_profile_derived_del");
 570
 571         private static void profile_derived_del(System.IntPtr obj, System.IntPtr pd, System.String profile)
 572         {
 573             Eina.Log.Debug("function efl_config_profile_derived_del was called");
 574             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 575             if (wrapper != null)
 576             {
 577
 578                 try
 579                 {
 580                     ((ConfigGlobal)wrapper).DelProfileDerived(profile);
 581                 }
 582                 catch (Exception e)
 583                 {
 584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 586                 }
 587
 588
 589             }
 590             else
 591             {
 592                 efl_config_profile_derived_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), profile);
 593             }
 594         }
 595
 596         private static efl_config_profile_derived_del_delegate efl_config_profile_derived_del_static_delegate;
 597
 598         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshalerOwn))]
 599         private delegate Eina.Value efl_config_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
 600
 601         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshalerOwn))]
 602         public delegate Eina.Value efl_config_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
 603
 604         public static Efl.Eo.FunctionWrapper<efl_config_get_api_delegate> efl_config_get_ptr = new Efl.Eo.FunctionWrapper<efl_config_get_api_delegate>(Module, "efl_config_get");
 605
 606         private static Eina.Value config_get(System.IntPtr obj, System.IntPtr pd, System.String name)
 607         {
 608             Eina.Log.Debug("function efl_config_get was called");
 609             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 610             if (wrapper != null)
 611             {
 612                                     Eina.Value _ret_var = default(Eina.Value);
 613                 try
 614                 {
 615                     _ret_var = ((ConfigGlobal)wrapper).GetConfig(name);
 616                 }
 617                 catch (Exception e)
 618                 {
 619                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 620                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 621                 }
 622
 623                         return _ret_var;
 624
 625             }
 626             else
 627             {
 628                 return efl_config_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
 629             }
 630         }
 631
 632         private static efl_config_get_delegate efl_config_get_static_delegate;
 633
 634         [return: MarshalAs(UnmanagedType.U1)]
 635         private delegate bool efl_config_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))] Eina.Value value);
 636
 637         [return: MarshalAs(UnmanagedType.U1)]
 638         public delegate bool efl_config_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))] Eina.Value value);
 639
 640         public static Efl.Eo.FunctionWrapper<efl_config_set_api_delegate> efl_config_set_ptr = new Efl.Eo.FunctionWrapper<efl_config_set_api_delegate>(Module, "efl_config_set");
 641
 642         private static bool config_set(System.IntPtr obj, System.IntPtr pd, System.String name, Eina.Value value)
 643         {
 644             Eina.Log.Debug("function efl_config_set was called");
 645             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 646             if (wrapper != null)
 647             {
 648                                                             bool _ret_var = default(bool);
 649                 try
 650                 {
 651                     _ret_var = ((ConfigGlobal)wrapper).SetConfig(name, value);
 652                 }
 653                 catch (Exception e)
 654                 {
 655                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 656                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 657                 }
 658
 659                                         return _ret_var;
 660
 661             }
 662             else
 663             {
 664                 return efl_config_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, value);
 665             }
 666         }
 667
 668         private static efl_config_set_delegate efl_config_set_static_delegate;
 669
 670         #pragma warning restore CA1707, SA1300, SA1600
 671
 672 }
 673 }
 674 }
 675