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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Gfx {
  11
  12 public partial class Constants
  13 {
  14     public static readonly double HintExpand = 1.000000;
  15 }
  16 }
  17
  18 }
  19
  20 namespace Efl {
  21
  22 namespace Gfx {
  23
  24 /// <summary>Efl graphics hint interface
  25 /// (Since EFL 1.22)</summary>
  26 [Efl.Gfx.IHintConcrete.NativeMethods]
  27 public interface IHint :
  28     Efl.Eo.IWrapper, IDisposable
  29 {
  30     /// <summary>Defines the aspect ratio to respect when scaling this object.
  31 /// The aspect ratio is defined as the width / height ratio of the object. Depending on the object and its container, this hint may or may not be fully respected.
  32 ///
  33 /// If any of the given aspect ratio terms are 0, the object&apos;s container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
  34 /// (Since EFL 1.22)</summary>
  35 /// <param name="mode">Mode of interpretation.</param>
  36 /// <param name="sz">Base size to use for aspecting.</param>
  37 void GetHintAspect(out Efl.Gfx.HintAspect mode, out Eina.Size2D sz);
  38     /// <summary>Defines the aspect ratio to respect when scaling this object.
  39 /// The aspect ratio is defined as the width / height ratio of the object. Depending on the object and its container, this hint may or may not be fully respected.
  40 ///
  41 /// If any of the given aspect ratio terms are 0, the object&apos;s container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
  42 /// (Since EFL 1.22)</summary>
  43 /// <param name="mode">Mode of interpretation.</param>
  44 /// <param name="sz">Base size to use for aspecting.</param>
  45 void SetHintAspect(Efl.Gfx.HintAspect mode, Eina.Size2D sz);
  46     /// <summary>Hints on the object&apos;s maximum size.
  47 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  48 ///
  49 /// The object container is in charge of fetching this property and placing the object accordingly.
  50 ///
  51 /// Values -1 will be treated as unset hint components, when queried by managers.
  52 ///
  53 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
  54 /// (Since EFL 1.22)</summary>
  55 /// <returns>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</returns>
  56 Eina.Size2D GetHintSizeMax();
  57     /// <summary>Hints on the object&apos;s maximum size.
  58 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  59 ///
  60 /// The object container is in charge of fetching this property and placing the object accordingly.
  61 ///
  62 /// Values -1 will be treated as unset hint components, when queried by managers.
  63 ///
  64 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
  65 /// (Since EFL 1.22)</summary>
  66 /// <param name="sz">Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</param>
  67 void SetHintSizeMax(Eina.Size2D sz);
  68     /// <summary>Hints on the object&apos;s minimum size.
  69 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
  70 ///
  71 /// Value 0 will be treated as unset hint components, when queried by managers.
  72 ///
  73 /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
  74 /// (Since EFL 1.22)</summary>
  75 /// <returns>Minimum size (hint) in pixels.</returns>
  76 Eina.Size2D GetHintSizeMin();
  77     /// <summary>Hints on the object&apos;s minimum size.
  78 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
  79 ///
  80 /// Value 0 will be treated as unset hint components, when queried by managers.
  81 ///
  82 /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
  83 /// (Since EFL 1.22)</summary>
  84 /// <param name="sz">Minimum size (hint) in pixels.</param>
  85 void SetHintSizeMin(Eina.Size2D sz);
  86     /// <summary>Get the &quot;intrinsic&quot; minimum size of this object.
  87 /// (Since EFL 1.22)</summary>
  88 /// <returns>Minimum size (hint) in pixels.</returns>
  89 Eina.Size2D GetHintSizeRestrictedMin();
  90     /// <summary>This function is protected as it is meant for widgets to indicate their &quot;intrinsic&quot; minimum size.
  91 /// (Since EFL 1.22)</summary>
  92 /// <param name="sz">Minimum size (hint) in pixels.</param>
  93 void SetHintSizeRestrictedMin(Eina.Size2D sz);
  94     /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.IHint.HintSizeMin"/> hints.
  95 /// <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.IHint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.IHint.GetHintSizeCombinedMin"/> combines both values by taking their repective maximum (in both width and height), and is used internally to get an object&apos;s minimum size.
  96 /// (Since EFL 1.22)</summary>
  97 /// <returns>Minimum size (hint) in pixels.</returns>
  98 Eina.Size2D GetHintSizeCombinedMin();
  99     /// <summary>Hints for an object&apos;s margin or padding space.
 100 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 101 ///
 102 /// The object container is in charge of fetching this property and placing the object accordingly.
 103 ///
 104 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 105 /// (Since EFL 1.22)</summary>
 106 /// <param name="l">Integer to specify left padding.</param>
 107 /// <param name="r">Integer to specify right padding.</param>
 108 /// <param name="t">Integer to specify top padding.</param>
 109 /// <param name="b">Integer to specify bottom padding.</param>
 110 void GetHintMargin(out int l, out int r, out int t, out int b);
 111     /// <summary>Hints for an object&apos;s margin or padding space.
 112 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 113 ///
 114 /// The object container is in charge of fetching this property and placing the object accordingly.
 115 ///
 116 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 117 /// (Since EFL 1.22)</summary>
 118 /// <param name="l">Integer to specify left padding.</param>
 119 /// <param name="r">Integer to specify right padding.</param>
 120 /// <param name="t">Integer to specify top padding.</param>
 121 /// <param name="b">Integer to specify bottom padding.</param>
 122 void SetHintMargin(int l, int r, int t, int b);
 123     /// <summary>Hints for an object&apos;s weight.
 124 /// This is a hint on how a container object should resize a given child within its area. Containers may adhere to the simpler logic of just expanding the child object&apos;s dimensions to fit its own (see the <see cref="Efl.Gfx.Constants.HintExpand"/> helper weight macro) or the complete one of taking each child&apos;s weight hint as real weights to how much of its size to allocate for them in each axis. A container is supposed to, after normalizing the weights of its children (with weight  hints), distribut the space it has to layout them by those factors -- most weighted children get larger in this process than the least ones.
 125 ///
 126 /// Accepted values are zero or positive values. Some containers might use this hint as a boolean, but some others might consider it as a proportion, see documentation of each container.
 127 ///
 128 /// Note: Default weight hint values are 0.0, for both axis.
 129 /// (Since EFL 1.22)</summary>
 130 /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 131 /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 132 void GetHintWeight(out double x, out double y);
 133     /// <summary>Hints for an object&apos;s weight.
 134 /// This is a hint on how a container object should resize a given child within its area. Containers may adhere to the simpler logic of just expanding the child object&apos;s dimensions to fit its own (see the <see cref="Efl.Gfx.Constants.HintExpand"/> helper weight macro) or the complete one of taking each child&apos;s weight hint as real weights to how much of its size to allocate for them in each axis. A container is supposed to, after normalizing the weights of its children (with weight  hints), distribut the space it has to layout them by those factors -- most weighted children get larger in this process than the least ones.
 135 ///
 136 /// Accepted values are zero or positive values. Some containers might use this hint as a boolean, but some others might consider it as a proportion, see documentation of each container.
 137 ///
 138 /// Note: Default weight hint values are 0.0, for both axis.
 139 /// (Since EFL 1.22)</summary>
 140 /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 141 /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 142 void SetHintWeight(double x, double y);
 143     /// <summary>Hints for an object&apos;s alignment.
 144 /// These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 1.0 range.
 145 ///
 146 /// For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.
 147 ///
 148 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 149 ///
 150 /// Note: Default alignment hint values are 0.5, for both axes.
 151 /// (Since EFL 1.22)</summary>
 152 /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 153 /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 154 void GetHintAlign(out double x, out double y);
 155     /// <summary>Hints for an object&apos;s alignment.
 156 /// These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 1.0 range.
 157 ///
 158 /// For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.
 159 ///
 160 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 161 ///
 162 /// Note: Default alignment hint values are 0.5, for both axes.
 163 /// (Since EFL 1.22)</summary>
 164 /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 165 /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 166 void SetHintAlign(double x, double y);
 167     /// <summary>Hints for an object&apos;s fill property that used to specify &quot;justify&quot; or &quot;fill&quot; by some users. <see cref="Efl.Gfx.IHint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 168 /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.IHint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 169 ///
 170 /// See documentation of possible users: in Evas, they are the <see cref="Efl.Ui.Box"/> &quot;box&quot; and <see cref="Efl.Ui.Table"/> &quot;table&quot; smart objects.
 171 ///
 172 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 173 ///
 174 /// Note: Default fill hint values are true, for both axes.
 175 /// (Since EFL 1.22)</summary>
 176 /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 177 /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 178 void GetHintFill(out bool x, out bool y);
 179     /// <summary>Hints for an object&apos;s fill property that used to specify &quot;justify&quot; or &quot;fill&quot; by some users. <see cref="Efl.Gfx.IHint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 180 /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.IHint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 181 ///
 182 /// See documentation of possible users: in Evas, they are the <see cref="Efl.Ui.Box"/> &quot;box&quot; and <see cref="Efl.Ui.Table"/> &quot;table&quot; smart objects.
 183 ///
 184 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 185 ///
 186 /// Note: Default fill hint values are true, for both axes.
 187 /// (Since EFL 1.22)</summary>
 188 /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 189 /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 190 void SetHintFill(bool x, bool y);
 191                                                                         /// <summary>Object hints changed.
 192     /// (Since EFL 1.22)</summary>
 193     event EventHandler HintsChangedEvt;
 194     /// <summary>Hints on the object&apos;s maximum size.
 195 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 196 ///
 197 /// The object container is in charge of fetching this property and placing the object accordingly.
 198 ///
 199 /// Values -1 will be treated as unset hint components, when queried by managers.
 200 ///
 201 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 202 /// (Since EFL 1.22)</summary>
 203 /// <value>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</value>
 204     Eina.Size2D HintSizeMax {
 205         get ;
 206         set ;
 207     }
 208     /// <summary>Hints on the object&apos;s minimum size.
 209 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
 210 ///
 211 /// Value 0 will be treated as unset hint components, when queried by managers.
 212 ///
 213 /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
 214 /// (Since EFL 1.22)</summary>
 215 /// <value>Minimum size (hint) in pixels.</value>
 216     Eina.Size2D HintSizeMin {
 217         get ;
 218         set ;
 219     }
 220     /// <summary>Internal hints for an object&apos;s minimum size.
 221 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 222 ///
 223 /// Values 0 will be treated as unset hint components, when queried by managers.
 224 ///
 225 /// Note: This property is internal and meant for widget developers to define the absolute minimum size of the object. EFL itself sets this size internally, so any change to it from an application might be ignored. Use <see cref="Efl.Gfx.IHint.HintSizeMin"/> instead.
 226 /// (Since EFL 1.22)</summary>
 227 /// <value>Minimum size (hint) in pixels.</value>
 228     Eina.Size2D HintSizeRestrictedMin {
 229         get ;
 230         set ;
 231     }
 232     /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.IHint.HintSizeMin"/> hints.
 233 /// <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.IHint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.IHint.GetHintSizeCombinedMin"/> combines both values by taking their repective maximum (in both width and height), and is used internally to get an object&apos;s minimum size.
 234 /// (Since EFL 1.22)</summary>
 235 /// <value>Minimum size (hint) in pixels.</value>
 236     Eina.Size2D HintSizeCombinedMin {
 237         get ;
 238     }
 239 }
 240 /// <summary>Efl graphics hint interface
 241 /// (Since EFL 1.22)</summary>
 242 sealed public class IHintConcrete :
 243
 244 IHint
 245
 246 {
 247     ///<summary>Pointer to the native class description.</summary>
 248     public System.IntPtr NativeClass
 249     {
 250         get
 251         {
 252             if (((object)this).GetType() == typeof(IHintConcrete))
 253             {
 254                 return GetEflClassStatic();
 255             }
 256             else
 257             {
 258                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 259             }
 260         }
 261     }
 262
 263     private Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)> eoEvents = new Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)>();
 264     private readonly object eventLock = new object();
 265     private  System.IntPtr handle;
 266     ///<summary>Pointer to the native instance.</summary>
 267     public System.IntPtr NativeHandle
 268     {
 269         get { return handle; }
 270     }
 271
 272     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 273         efl_gfx_hint_interface_get();
 274     /// <summary>Initializes a new instance of the <see cref="IHint"/> class.
 275     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 276     private IHintConcrete(System.IntPtr raw)
 277     {
 278         handle = raw;
 279     }
 280     ///<summary>Destructor.</summary>
 281     ~IHintConcrete()
 282     {
 283         Dispose(false);
 284     }
 285
 286     ///<summary>Releases the underlying native instance.</summary>
 287     private void Dispose(bool disposing)
 288     {
 289         if (handle != System.IntPtr.Zero)
 290         {
 291             IntPtr h = handle;
 292             handle = IntPtr.Zero;
 293
 294             IntPtr gcHandlePtr = IntPtr.Zero;
 295             if (eoEvents.Count != 0)
 296             {
 297                 GCHandle gcHandle = GCHandle.Alloc(eoEvents);
 298                 gcHandlePtr = GCHandle.ToIntPtr(gcHandle);
 299             }
 300
 301             if (disposing)
 302             {
 303                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 304             }
 305             else
 306             {
 307                 Monitor.Enter(Efl.All.InitLock);
 308                 if (Efl.All.MainLoopInitialized)
 309                 {
 310                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 311                 }
 312
 313                 Monitor.Exit(Efl.All.InitLock);
 314             }
 315         }
 316
 317     }
 318
 319     ///<summary>Releases the underlying native instance.</summary>
 320     public void Dispose()
 321     {
 322         Dispose(true);
 323         GC.SuppressFinalize(this);
 324     }
 325
 326     /// <summary>Verifies if the given object is equal to this one.</summary>
 327     /// <param name="instance">The object to compare to.</param>
 328     /// <returns>True if both objects point to the same native object.</returns>
 329     public override bool Equals(object instance)
 330     {
 331         var other = instance as Efl.Object;
 332         if (other == null)
 333         {
 334             return false;
 335         }
 336         return this.NativeHandle == other.NativeHandle;
 337     }
 338
 339     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 340     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 341     public override int GetHashCode()
 342     {
 343         return this.NativeHandle.ToInt32();
 344     }
 345
 346     /// <summary>Turns the native pointer into a string representation.</summary>
 347     /// <returns>A string with the type and the native pointer for this object.</returns>
 348     public override String ToString()
 349     {
 350         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 351     }
 352
 353     ///<summary>Adds a new event handler, registering it to the native event. For internal use only.</summary>
 354     ///<param name="lib">The name of the native library definining the event.</param>
 355     ///<param name="key">The name of the native event.</param>
 356     ///<param name="evtCaller">Delegate to be called by native code on event raising.</param>
 357     ///<param name="evtDelegate">Managed delegate that will be called by evtCaller on event raising.</param>
 358     private void AddNativeEventHandler(string lib, string key, Efl.EventCb evtCaller, object evtDelegate)
 359     {
 360         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 361         if (desc == IntPtr.Zero)
 362         {
 363             Eina.Log.Error($"Failed to get native event {key}");
 364         }
 365
 366         if (eoEvents.ContainsKey((desc, evtDelegate)))
 367         {
 368             Eina.Log.Warning($"Event proxy for event {key} already registered!");
 369             return;
 370         }
 371
 372         IntPtr evtCallerPtr = Marshal.GetFunctionPointerForDelegate(evtCaller);
 373         if (!Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evtCallerPtr, IntPtr.Zero))
 374         {
 375             Eina.Log.Error($"Failed to add event proxy for event {key}");
 376             return;
 377         }
 378
 379         eoEvents[(desc, evtDelegate)] = (evtCallerPtr, evtCaller);
 380         Eina.Error.RaiseIfUnhandledException();
 381     }
 382
 383     ///<summary>Removes the given event handler for the given event. For internal use only.</summary>
 384     ///<param name="lib">The name of the native library definining the event.</param>
 385     ///<param name="key">The name of the native event.</param>
 386     ///<param name="evtDelegate">The delegate to be removed.</param>
 387     private void RemoveNativeEventHandler(string lib, string key, object evtDelegate)
 388     {
 389         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 390         if (desc == IntPtr.Zero)
 391         {
 392             Eina.Log.Error($"Failed to get native event {key}");
 393             return;
 394         }
 395
 396         var evtPair = (desc, evtDelegate);
 397         if (eoEvents.TryGetValue(evtPair, out var caller))
 398         {
 399             if (!Efl.Eo.Globals.efl_event_callback_del(handle, desc, caller.evtCallerPtr, IntPtr.Zero))
 400             {
 401                 Eina.Log.Error($"Failed to remove event proxy for event {key}");
 402                 return;
 403             }
 404
 405             eoEvents.Remove(evtPair);
 406             Eina.Error.RaiseIfUnhandledException();
 407         }
 408         else
 409         {
 410             Eina.Log.Error($"Trying to remove proxy for event {key} when it is nothing registered.");
 411         }
 412     }
 413
 414     /// <summary>Object hints changed.
 415     /// (Since EFL 1.22)</summary>
 416     public event EventHandler HintsChangedEvt
 417     {
 418         add
 419         {
 420             lock (eventLock)
 421             {
 422                 var wRef = new WeakReference(this);
 423                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 424                 {
 425                     var obj = wRef.Target as Efl.Eo.IWrapper;
 426                     if (obj != null)
 427                     {
 428                         EventArgs args = EventArgs.Empty;
 429                         try
 430                         {
 431                             value?.Invoke(obj, args);
 432                         }
 433                         catch (Exception e)
 434                         {
 435                             Eina.Log.Error(e.ToString());
 436                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 437                         }
 438                     }
 439                 };
 440
 441                 string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
 442                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 443             }
 444         }
 445
 446         remove
 447         {
 448             lock (eventLock)
 449             {
 450                 string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
 451                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 452             }
 453         }
 454     }
 455     ///<summary>Method to raise event HintsChangedEvt.</summary>
 456     public void OnHintsChangedEvt(EventArgs e)
 457     {
 458         var key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
 459         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 460         if (desc == IntPtr.Zero)
 461         {
 462             Eina.Log.Error($"Failed to get native event {key}");
 463             return;
 464         }
 465
 466         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 467     }
 468     /// <summary>Defines the aspect ratio to respect when scaling this object.
 469     /// The aspect ratio is defined as the width / height ratio of the object. Depending on the object and its container, this hint may or may not be fully respected.
 470     ///
 471     /// If any of the given aspect ratio terms are 0, the object&apos;s container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
 472     /// (Since EFL 1.22)</summary>
 473     /// <param name="mode">Mode of interpretation.</param>
 474     /// <param name="sz">Base size to use for aspecting.</param>
 475     public void GetHintAspect(out Efl.Gfx.HintAspect mode, out Eina.Size2D sz) {
 476                                  var _out_sz = new Eina.Size2D.NativeStruct();
 477                         Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_aspect_get_ptr.Value.Delegate(this.NativeHandle,out mode, out _out_sz);
 478         Eina.Error.RaiseIfUnhandledException();
 479                 sz = _out_sz;
 480                          }
 481     /// <summary>Defines the aspect ratio to respect when scaling this object.
 482     /// The aspect ratio is defined as the width / height ratio of the object. Depending on the object and its container, this hint may or may not be fully respected.
 483     ///
 484     /// If any of the given aspect ratio terms are 0, the object&apos;s container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
 485     /// (Since EFL 1.22)</summary>
 486     /// <param name="mode">Mode of interpretation.</param>
 487     /// <param name="sz">Base size to use for aspecting.</param>
 488     public void SetHintAspect(Efl.Gfx.HintAspect mode, Eina.Size2D sz) {
 489                  Eina.Size2D.NativeStruct _in_sz = sz;
 490                                         Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_aspect_set_ptr.Value.Delegate(this.NativeHandle,mode, _in_sz);
 491         Eina.Error.RaiseIfUnhandledException();
 492                                          }
 493     /// <summary>Hints on the object&apos;s maximum size.
 494     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 495     ///
 496     /// The object container is in charge of fetching this property and placing the object accordingly.
 497     ///
 498     /// Values -1 will be treated as unset hint components, when queried by managers.
 499     ///
 500     /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 501     /// (Since EFL 1.22)</summary>
 502     /// <returns>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</returns>
 503     public Eina.Size2D GetHintSizeMax() {
 504          var _ret_var = Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_max_get_ptr.Value.Delegate(this.NativeHandle);
 505         Eina.Error.RaiseIfUnhandledException();
 506         return _ret_var;
 507  }
 508     /// <summary>Hints on the object&apos;s maximum size.
 509     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 510     ///
 511     /// The object container is in charge of fetching this property and placing the object accordingly.
 512     ///
 513     /// Values -1 will be treated as unset hint components, when queried by managers.
 514     ///
 515     /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 516     /// (Since EFL 1.22)</summary>
 517     /// <param name="sz">Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</param>
 518     public void SetHintSizeMax(Eina.Size2D sz) {
 519          Eina.Size2D.NativeStruct _in_sz = sz;
 520                         Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_max_set_ptr.Value.Delegate(this.NativeHandle,_in_sz);
 521         Eina.Error.RaiseIfUnhandledException();
 522                          }
 523     /// <summary>Hints on the object&apos;s minimum size.
 524     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
 525     ///
 526     /// Value 0 will be treated as unset hint components, when queried by managers.
 527     ///
 528     /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
 529     /// (Since EFL 1.22)</summary>
 530     /// <returns>Minimum size (hint) in pixels.</returns>
 531     public Eina.Size2D GetHintSizeMin() {
 532          var _ret_var = Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_min_get_ptr.Value.Delegate(this.NativeHandle);
 533         Eina.Error.RaiseIfUnhandledException();
 534         return _ret_var;
 535  }
 536     /// <summary>Hints on the object&apos;s minimum size.
 537     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
 538     ///
 539     /// Value 0 will be treated as unset hint components, when queried by managers.
 540     ///
 541     /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
 542     /// (Since EFL 1.22)</summary>
 543     /// <param name="sz">Minimum size (hint) in pixels.</param>
 544     public void SetHintSizeMin(Eina.Size2D sz) {
 545          Eina.Size2D.NativeStruct _in_sz = sz;
 546                         Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_min_set_ptr.Value.Delegate(this.NativeHandle,_in_sz);
 547         Eina.Error.RaiseIfUnhandledException();
 548                          }
 549     /// <summary>Get the &quot;intrinsic&quot; minimum size of this object.
 550     /// (Since EFL 1.22)</summary>
 551     /// <returns>Minimum size (hint) in pixels.</returns>
 552     public Eina.Size2D GetHintSizeRestrictedMin() {
 553          var _ret_var = Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(this.NativeHandle);
 554         Eina.Error.RaiseIfUnhandledException();
 555         return _ret_var;
 556  }
 557     /// <summary>This function is protected as it is meant for widgets to indicate their &quot;intrinsic&quot; minimum size.
 558     /// (Since EFL 1.22)</summary>
 559     /// <param name="sz">Minimum size (hint) in pixels.</param>
 560     public void SetHintSizeRestrictedMin(Eina.Size2D sz) {
 561          Eina.Size2D.NativeStruct _in_sz = sz;
 562                         Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(this.NativeHandle,_in_sz);
 563         Eina.Error.RaiseIfUnhandledException();
 564                          }
 565     /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.IHint.HintSizeMin"/> hints.
 566     /// <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.IHint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.IHint.GetHintSizeCombinedMin"/> combines both values by taking their repective maximum (in both width and height), and is used internally to get an object&apos;s minimum size.
 567     /// (Since EFL 1.22)</summary>
 568     /// <returns>Minimum size (hint) in pixels.</returns>
 569     public Eina.Size2D GetHintSizeCombinedMin() {
 570          var _ret_var = Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(this.NativeHandle);
 571         Eina.Error.RaiseIfUnhandledException();
 572         return _ret_var;
 573  }
 574     /// <summary>Hints for an object&apos;s margin or padding space.
 575     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 576     ///
 577     /// The object container is in charge of fetching this property and placing the object accordingly.
 578     ///
 579     /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 580     /// (Since EFL 1.22)</summary>
 581     /// <param name="l">Integer to specify left padding.</param>
 582     /// <param name="r">Integer to specify right padding.</param>
 583     /// <param name="t">Integer to specify top padding.</param>
 584     /// <param name="b">Integer to specify bottom padding.</param>
 585     public void GetHintMargin(out int l, out int r, out int t, out int b) {
 586                                                                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_margin_get_ptr.Value.Delegate(this.NativeHandle,out l, out r, out t, out b);
 587         Eina.Error.RaiseIfUnhandledException();
 588                                                                          }
 589     /// <summary>Hints for an object&apos;s margin or padding space.
 590     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 591     ///
 592     /// The object container is in charge of fetching this property and placing the object accordingly.
 593     ///
 594     /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 595     /// (Since EFL 1.22)</summary>
 596     /// <param name="l">Integer to specify left padding.</param>
 597     /// <param name="r">Integer to specify right padding.</param>
 598     /// <param name="t">Integer to specify top padding.</param>
 599     /// <param name="b">Integer to specify bottom padding.</param>
 600     public void SetHintMargin(int l, int r, int t, int b) {
 601                                                                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_margin_set_ptr.Value.Delegate(this.NativeHandle,l, r, t, b);
 602         Eina.Error.RaiseIfUnhandledException();
 603                                                                          }
 604     /// <summary>Hints for an object&apos;s weight.
 605     /// This is a hint on how a container object should resize a given child within its area. Containers may adhere to the simpler logic of just expanding the child object&apos;s dimensions to fit its own (see the <see cref="Efl.Gfx.Constants.HintExpand"/> helper weight macro) or the complete one of taking each child&apos;s weight hint as real weights to how much of its size to allocate for them in each axis. A container is supposed to, after normalizing the weights of its children (with weight  hints), distribut the space it has to layout them by those factors -- most weighted children get larger in this process than the least ones.
 606     ///
 607     /// Accepted values are zero or positive values. Some containers might use this hint as a boolean, but some others might consider it as a proportion, see documentation of each container.
 608     ///
 609     /// Note: Default weight hint values are 0.0, for both axis.
 610     /// (Since EFL 1.22)</summary>
 611     /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 612     /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 613     public void GetHintWeight(out double x, out double y) {
 614                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_weight_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 615         Eina.Error.RaiseIfUnhandledException();
 616                                          }
 617     /// <summary>Hints for an object&apos;s weight.
 618     /// This is a hint on how a container object should resize a given child within its area. Containers may adhere to the simpler logic of just expanding the child object&apos;s dimensions to fit its own (see the <see cref="Efl.Gfx.Constants.HintExpand"/> helper weight macro) or the complete one of taking each child&apos;s weight hint as real weights to how much of its size to allocate for them in each axis. A container is supposed to, after normalizing the weights of its children (with weight  hints), distribut the space it has to layout them by those factors -- most weighted children get larger in this process than the least ones.
 619     ///
 620     /// Accepted values are zero or positive values. Some containers might use this hint as a boolean, but some others might consider it as a proportion, see documentation of each container.
 621     ///
 622     /// Note: Default weight hint values are 0.0, for both axis.
 623     /// (Since EFL 1.22)</summary>
 624     /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 625     /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 626     public void SetHintWeight(double x, double y) {
 627                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_weight_set_ptr.Value.Delegate(this.NativeHandle,x, y);
 628         Eina.Error.RaiseIfUnhandledException();
 629                                          }
 630     /// <summary>Hints for an object&apos;s alignment.
 631     /// These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 1.0 range.
 632     ///
 633     /// For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.
 634     ///
 635     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 636     ///
 637     /// Note: Default alignment hint values are 0.5, for both axes.
 638     /// (Since EFL 1.22)</summary>
 639     /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 640     /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 641     public void GetHintAlign(out double x, out double y) {
 642                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_align_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 643         Eina.Error.RaiseIfUnhandledException();
 644                                          }
 645     /// <summary>Hints for an object&apos;s alignment.
 646     /// These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 1.0 range.
 647     ///
 648     /// For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.
 649     ///
 650     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 651     ///
 652     /// Note: Default alignment hint values are 0.5, for both axes.
 653     /// (Since EFL 1.22)</summary>
 654     /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 655     /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 656     public void SetHintAlign(double x, double y) {
 657                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_align_set_ptr.Value.Delegate(this.NativeHandle,x, y);
 658         Eina.Error.RaiseIfUnhandledException();
 659                                          }
 660     /// <summary>Hints for an object&apos;s fill property that used to specify &quot;justify&quot; or &quot;fill&quot; by some users. <see cref="Efl.Gfx.IHint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 661     /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.IHint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 662     ///
 663     /// See documentation of possible users: in Evas, they are the <see cref="Efl.Ui.Box"/> &quot;box&quot; and <see cref="Efl.Ui.Table"/> &quot;table&quot; smart objects.
 664     ///
 665     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 666     ///
 667     /// Note: Default fill hint values are true, for both axes.
 668     /// (Since EFL 1.22)</summary>
 669     /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 670     /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 671     public void GetHintFill(out bool x, out bool y) {
 672                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_fill_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 673         Eina.Error.RaiseIfUnhandledException();
 674                                          }
 675     /// <summary>Hints for an object&apos;s fill property that used to specify &quot;justify&quot; or &quot;fill&quot; by some users. <see cref="Efl.Gfx.IHint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 676     /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.IHint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 677     ///
 678     /// See documentation of possible users: in Evas, they are the <see cref="Efl.Ui.Box"/> &quot;box&quot; and <see cref="Efl.Ui.Table"/> &quot;table&quot; smart objects.
 679     ///
 680     /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 681     ///
 682     /// Note: Default fill hint values are true, for both axes.
 683     /// (Since EFL 1.22)</summary>
 684     /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 685     /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 686     public void SetHintFill(bool x, bool y) {
 687                                                          Efl.Gfx.IHintConcrete.NativeMethods.efl_gfx_hint_fill_set_ptr.Value.Delegate(this.NativeHandle,x, y);
 688         Eina.Error.RaiseIfUnhandledException();
 689                                          }
 690     /// <summary>Hints on the object&apos;s maximum size.
 691 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 692 ///
 693 /// The object container is in charge of fetching this property and placing the object accordingly.
 694 ///
 695 /// Values -1 will be treated as unset hint components, when queried by managers.
 696 ///
 697 /// Note: Smart objects (such as elementary) can have their own hint policy. So calling this API may or may not affect the size of smart objects.
 698 /// (Since EFL 1.22)</summary>
 699 /// <value>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</value>
 700     public Eina.Size2D HintSizeMax {
 701         get { return GetHintSizeMax(); }
 702         set { SetHintSizeMax(value); }
 703     }
 704     /// <summary>Hints on the object&apos;s minimum size.
 705 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate. The object container is in charge of fetching this property and placing the object accordingly.
 706 ///
 707 /// Value 0 will be treated as unset hint components, when queried by managers.
 708 ///
 709 /// Note: This property is meant to be set by applications and not by EFL itself. Use this to request a specific size (treated as minimum size).
 710 /// (Since EFL 1.22)</summary>
 711 /// <value>Minimum size (hint) in pixels.</value>
 712     public Eina.Size2D HintSizeMin {
 713         get { return GetHintSizeMin(); }
 714         set { SetHintSizeMin(value); }
 715     }
 716     /// <summary>Internal hints for an object&apos;s minimum size.
 717 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 718 ///
 719 /// Values 0 will be treated as unset hint components, when queried by managers.
 720 ///
 721 /// Note: This property is internal and meant for widget developers to define the absolute minimum size of the object. EFL itself sets this size internally, so any change to it from an application might be ignored. Use <see cref="Efl.Gfx.IHint.HintSizeMin"/> instead.
 722 /// (Since EFL 1.22)</summary>
 723 /// <value>Minimum size (hint) in pixels.</value>
 724     public Eina.Size2D HintSizeRestrictedMin {
 725         get { return GetHintSizeRestrictedMin(); }
 726         set { SetHintSizeRestrictedMin(value); }
 727     }
 728     /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.IHint.HintSizeMin"/> hints.
 729 /// <see cref="Efl.Gfx.IHint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.IHint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.IHint.GetHintSizeCombinedMin"/> combines both values by taking their repective maximum (in both width and height), and is used internally to get an object&apos;s minimum size.
 730 /// (Since EFL 1.22)</summary>
 731 /// <value>Minimum size (hint) in pixels.</value>
 732     public Eina.Size2D HintSizeCombinedMin {
 733         get { return GetHintSizeCombinedMin(); }
 734     }
 735     private static IntPtr GetEflClassStatic()
 736     {
 737         return Efl.Gfx.IHintConcrete.efl_gfx_hint_interface_get();
 738     }
 739     /// <summary>Wrapper for native methods and virtual method delegates.
 740     /// For internal use by generated code only.</summary>
 741     public class NativeMethods  : Efl.Eo.NativeClass
 742     {
 743         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 744         /// <summary>Gets the list of Eo operations to override.</summary>
 745         /// <returns>The list of Eo operations to be overload.</returns>
 746         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 747         {
 748             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 749             var methods = Efl.Eo.Globals.GetUserMethods(type);
 750
 751             if (efl_gfx_hint_aspect_get_static_delegate == null)
 752             {
 753                 efl_gfx_hint_aspect_get_static_delegate = new efl_gfx_hint_aspect_get_delegate(hint_aspect_get);
 754             }
 755
 756             if (methods.FirstOrDefault(m => m.Name == "GetHintAspect") != null)
 757             {
 758                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_aspect_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_aspect_get_static_delegate) });
 759             }
 760
 761             if (efl_gfx_hint_aspect_set_static_delegate == null)
 762             {
 763                 efl_gfx_hint_aspect_set_static_delegate = new efl_gfx_hint_aspect_set_delegate(hint_aspect_set);
 764             }
 765
 766             if (methods.FirstOrDefault(m => m.Name == "SetHintAspect") != null)
 767             {
 768                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_aspect_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_aspect_set_static_delegate) });
 769             }
 770
 771             if (efl_gfx_hint_size_max_get_static_delegate == null)
 772             {
 773                 efl_gfx_hint_size_max_get_static_delegate = new efl_gfx_hint_size_max_get_delegate(hint_size_max_get);
 774             }
 775
 776             if (methods.FirstOrDefault(m => m.Name == "GetHintSizeMax") != null)
 777             {
 778                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_max_get_static_delegate) });
 779             }
 780
 781             if (efl_gfx_hint_size_max_set_static_delegate == null)
 782             {
 783                 efl_gfx_hint_size_max_set_static_delegate = new efl_gfx_hint_size_max_set_delegate(hint_size_max_set);
 784             }
 785
 786             if (methods.FirstOrDefault(m => m.Name == "SetHintSizeMax") != null)
 787             {
 788                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_max_set_static_delegate) });
 789             }
 790
 791             if (efl_gfx_hint_size_min_get_static_delegate == null)
 792             {
 793                 efl_gfx_hint_size_min_get_static_delegate = new efl_gfx_hint_size_min_get_delegate(hint_size_min_get);
 794             }
 795
 796             if (methods.FirstOrDefault(m => m.Name == "GetHintSizeMin") != null)
 797             {
 798                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_min_get_static_delegate) });
 799             }
 800
 801             if (efl_gfx_hint_size_min_set_static_delegate == null)
 802             {
 803                 efl_gfx_hint_size_min_set_static_delegate = new efl_gfx_hint_size_min_set_delegate(hint_size_min_set);
 804             }
 805
 806             if (methods.FirstOrDefault(m => m.Name == "SetHintSizeMin") != null)
 807             {
 808                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_min_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_min_set_static_delegate) });
 809             }
 810
 811             if (efl_gfx_hint_size_restricted_min_get_static_delegate == null)
 812             {
 813                 efl_gfx_hint_size_restricted_min_get_static_delegate = new efl_gfx_hint_size_restricted_min_get_delegate(hint_size_restricted_min_get);
 814             }
 815
 816             if (methods.FirstOrDefault(m => m.Name == "GetHintSizeRestrictedMin") != null)
 817             {
 818                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_restricted_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_restricted_min_get_static_delegate) });
 819             }
 820
 821             if (efl_gfx_hint_size_restricted_min_set_static_delegate == null)
 822             {
 823                 efl_gfx_hint_size_restricted_min_set_static_delegate = new efl_gfx_hint_size_restricted_min_set_delegate(hint_size_restricted_min_set);
 824             }
 825
 826             if (methods.FirstOrDefault(m => m.Name == "SetHintSizeRestrictedMin") != null)
 827             {
 828                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_restricted_min_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_restricted_min_set_static_delegate) });
 829             }
 830
 831             if (efl_gfx_hint_size_combined_min_get_static_delegate == null)
 832             {
 833                 efl_gfx_hint_size_combined_min_get_static_delegate = new efl_gfx_hint_size_combined_min_get_delegate(hint_size_combined_min_get);
 834             }
 835
 836             if (methods.FirstOrDefault(m => m.Name == "GetHintSizeCombinedMin") != null)
 837             {
 838                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_size_combined_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_size_combined_min_get_static_delegate) });
 839             }
 840
 841             if (efl_gfx_hint_margin_get_static_delegate == null)
 842             {
 843                 efl_gfx_hint_margin_get_static_delegate = new efl_gfx_hint_margin_get_delegate(hint_margin_get);
 844             }
 845
 846             if (methods.FirstOrDefault(m => m.Name == "GetHintMargin") != null)
 847             {
 848                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_margin_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_margin_get_static_delegate) });
 849             }
 850
 851             if (efl_gfx_hint_margin_set_static_delegate == null)
 852             {
 853                 efl_gfx_hint_margin_set_static_delegate = new efl_gfx_hint_margin_set_delegate(hint_margin_set);
 854             }
 855
 856             if (methods.FirstOrDefault(m => m.Name == "SetHintMargin") != null)
 857             {
 858                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_margin_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_margin_set_static_delegate) });
 859             }
 860
 861             if (efl_gfx_hint_weight_get_static_delegate == null)
 862             {
 863                 efl_gfx_hint_weight_get_static_delegate = new efl_gfx_hint_weight_get_delegate(hint_weight_get);
 864             }
 865
 866             if (methods.FirstOrDefault(m => m.Name == "GetHintWeight") != null)
 867             {
 868                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_weight_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_weight_get_static_delegate) });
 869             }
 870
 871             if (efl_gfx_hint_weight_set_static_delegate == null)
 872             {
 873                 efl_gfx_hint_weight_set_static_delegate = new efl_gfx_hint_weight_set_delegate(hint_weight_set);
 874             }
 875
 876             if (methods.FirstOrDefault(m => m.Name == "SetHintWeight") != null)
 877             {
 878                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_weight_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_weight_set_static_delegate) });
 879             }
 880
 881             if (efl_gfx_hint_align_get_static_delegate == null)
 882             {
 883                 efl_gfx_hint_align_get_static_delegate = new efl_gfx_hint_align_get_delegate(hint_align_get);
 884             }
 885
 886             if (methods.FirstOrDefault(m => m.Name == "GetHintAlign") != null)
 887             {
 888                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_align_get_static_delegate) });
 889             }
 890
 891             if (efl_gfx_hint_align_set_static_delegate == null)
 892             {
 893                 efl_gfx_hint_align_set_static_delegate = new efl_gfx_hint_align_set_delegate(hint_align_set);
 894             }
 895
 896             if (methods.FirstOrDefault(m => m.Name == "SetHintAlign") != null)
 897             {
 898                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_align_set_static_delegate) });
 899             }
 900
 901             if (efl_gfx_hint_fill_get_static_delegate == null)
 902             {
 903                 efl_gfx_hint_fill_get_static_delegate = new efl_gfx_hint_fill_get_delegate(hint_fill_get);
 904             }
 905
 906             if (methods.FirstOrDefault(m => m.Name == "GetHintFill") != null)
 907             {
 908                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_fill_get_static_delegate) });
 909             }
 910
 911             if (efl_gfx_hint_fill_set_static_delegate == null)
 912             {
 913                 efl_gfx_hint_fill_set_static_delegate = new efl_gfx_hint_fill_set_delegate(hint_fill_set);
 914             }
 915
 916             if (methods.FirstOrDefault(m => m.Name == "SetHintFill") != null)
 917             {
 918                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_hint_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_hint_fill_set_static_delegate) });
 919             }
 920
 921             return descs;
 922         }
 923         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 924         /// <returns>The native class pointer.</returns>
 925         public override IntPtr GetEflClass()
 926         {
 927             return Efl.Gfx.IHintConcrete.efl_gfx_hint_interface_get();
 928         }
 929
 930         #pragma warning disable CA1707, SA1300, SA1600
 931
 932
 933         private delegate void efl_gfx_hint_aspect_get_delegate(System.IntPtr obj, System.IntPtr pd,  out Efl.Gfx.HintAspect mode,  out Eina.Size2D.NativeStruct sz);
 934
 935
 936         public delegate void efl_gfx_hint_aspect_get_api_delegate(System.IntPtr obj,  out Efl.Gfx.HintAspect mode,  out Eina.Size2D.NativeStruct sz);
 937
 938         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_aspect_get_api_delegate> efl_gfx_hint_aspect_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_aspect_get_api_delegate>(Module, "efl_gfx_hint_aspect_get");
 939
 940         private static void hint_aspect_get(System.IntPtr obj, System.IntPtr pd, out Efl.Gfx.HintAspect mode, out Eina.Size2D.NativeStruct sz)
 941         {
 942             Eina.Log.Debug("function efl_gfx_hint_aspect_get was called");
 943             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 944             if (wrapper != null)
 945             {
 946                         mode = default(Efl.Gfx.HintAspect);        Eina.Size2D _out_sz = default(Eina.Size2D);
 947
 948                 try
 949                 {
 950                     ((IHint)wrapper).GetHintAspect(out mode, out _out_sz);
 951                 }
 952                 catch (Exception e)
 953                 {
 954                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 955                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 956                 }
 957
 958                 sz = _out_sz;
 959
 960             }
 961             else
 962             {
 963                 efl_gfx_hint_aspect_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out mode, out sz);
 964             }
 965         }
 966
 967         private static efl_gfx_hint_aspect_get_delegate efl_gfx_hint_aspect_get_static_delegate;
 968
 969
 970         private delegate void efl_gfx_hint_aspect_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.HintAspect mode,  Eina.Size2D.NativeStruct sz);
 971
 972
 973         public delegate void efl_gfx_hint_aspect_set_api_delegate(System.IntPtr obj,  Efl.Gfx.HintAspect mode,  Eina.Size2D.NativeStruct sz);
 974
 975         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_aspect_set_api_delegate> efl_gfx_hint_aspect_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_aspect_set_api_delegate>(Module, "efl_gfx_hint_aspect_set");
 976
 977         private static void hint_aspect_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.HintAspect mode, Eina.Size2D.NativeStruct sz)
 978         {
 979             Eina.Log.Debug("function efl_gfx_hint_aspect_set was called");
 980             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 981             if (wrapper != null)
 982             {
 983                 Eina.Size2D _in_sz = sz;
 984
 985                 try
 986                 {
 987                     ((IHint)wrapper).SetHintAspect(mode, _in_sz);
 988                 }
 989                 catch (Exception e)
 990                 {
 991                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 992                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 993                 }
 994
 995
 996             }
 997             else
 998             {
 999                 efl_gfx_hint_aspect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode, sz);
1000             }
1001         }
1002
1003         private static efl_gfx_hint_aspect_set_delegate efl_gfx_hint_aspect_set_static_delegate;
1004
1005
1006         private delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
1007
1008
1009         public delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_max_get_api_delegate(System.IntPtr obj);
1010
1011         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_max_get_api_delegate> efl_gfx_hint_size_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_max_get_api_delegate>(Module, "efl_gfx_hint_size_max_get");
1012
1013         private static Eina.Size2D.NativeStruct hint_size_max_get(System.IntPtr obj, System.IntPtr pd)
1014         {
1015             Eina.Log.Debug("function efl_gfx_hint_size_max_get was called");
1016             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1017             if (wrapper != null)
1018             {
1019             Eina.Size2D _ret_var = default(Eina.Size2D);
1020                 try
1021                 {
1022                     _ret_var = ((IHint)wrapper).GetHintSizeMax();
1023                 }
1024                 catch (Exception e)
1025                 {
1026                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1027                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1028                 }
1029
1030         return _ret_var;
1031
1032             }
1033             else
1034             {
1035                 return efl_gfx_hint_size_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1036             }
1037         }
1038
1039         private static efl_gfx_hint_size_max_get_delegate efl_gfx_hint_size_max_get_static_delegate;
1040
1041
1042         private delegate void efl_gfx_hint_size_max_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct sz);
1043
1044
1045         public delegate void efl_gfx_hint_size_max_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct sz);
1046
1047         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_max_set_api_delegate> efl_gfx_hint_size_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_max_set_api_delegate>(Module, "efl_gfx_hint_size_max_set");
1048
1049         private static void hint_size_max_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct sz)
1050         {
1051             Eina.Log.Debug("function efl_gfx_hint_size_max_set was called");
1052             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1053             if (wrapper != null)
1054             {
1055         Eina.Size2D _in_sz = sz;
1056
1057                 try
1058                 {
1059                     ((IHint)wrapper).SetHintSizeMax(_in_sz);
1060                 }
1061                 catch (Exception e)
1062                 {
1063                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1064                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1065                 }
1066
1067
1068             }
1069             else
1070             {
1071                 efl_gfx_hint_size_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
1072             }
1073         }
1074
1075         private static efl_gfx_hint_size_max_set_delegate efl_gfx_hint_size_max_set_static_delegate;
1076
1077
1078         private delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
1079
1080
1081         public delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_min_get_api_delegate(System.IntPtr obj);
1082
1083         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_min_get_api_delegate> efl_gfx_hint_size_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_min_get_api_delegate>(Module, "efl_gfx_hint_size_min_get");
1084
1085         private static Eina.Size2D.NativeStruct hint_size_min_get(System.IntPtr obj, System.IntPtr pd)
1086         {
1087             Eina.Log.Debug("function efl_gfx_hint_size_min_get was called");
1088             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1089             if (wrapper != null)
1090             {
1091             Eina.Size2D _ret_var = default(Eina.Size2D);
1092                 try
1093                 {
1094                     _ret_var = ((IHint)wrapper).GetHintSizeMin();
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100                 }
1101
1102         return _ret_var;
1103
1104             }
1105             else
1106             {
1107                 return efl_gfx_hint_size_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1108             }
1109         }
1110
1111         private static efl_gfx_hint_size_min_get_delegate efl_gfx_hint_size_min_get_static_delegate;
1112
1113
1114         private delegate void efl_gfx_hint_size_min_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct sz);
1115
1116
1117         public delegate void efl_gfx_hint_size_min_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct sz);
1118
1119         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_min_set_api_delegate> efl_gfx_hint_size_min_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_min_set_api_delegate>(Module, "efl_gfx_hint_size_min_set");
1120
1121         private static void hint_size_min_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct sz)
1122         {
1123             Eina.Log.Debug("function efl_gfx_hint_size_min_set was called");
1124             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1125             if (wrapper != null)
1126             {
1127         Eina.Size2D _in_sz = sz;
1128
1129                 try
1130                 {
1131                     ((IHint)wrapper).SetHintSizeMin(_in_sz);
1132                 }
1133                 catch (Exception e)
1134                 {
1135                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1136                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1137                 }
1138
1139
1140             }
1141             else
1142             {
1143                 efl_gfx_hint_size_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
1144             }
1145         }
1146
1147         private static efl_gfx_hint_size_min_set_delegate efl_gfx_hint_size_min_set_static_delegate;
1148
1149
1150         private delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_restricted_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
1151
1152
1153         public delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_restricted_min_get_api_delegate(System.IntPtr obj);
1154
1155         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_restricted_min_get_api_delegate> efl_gfx_hint_size_restricted_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_restricted_min_get_api_delegate>(Module, "efl_gfx_hint_size_restricted_min_get");
1156
1157         private static Eina.Size2D.NativeStruct hint_size_restricted_min_get(System.IntPtr obj, System.IntPtr pd)
1158         {
1159             Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_get was called");
1160             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1161             if (wrapper != null)
1162             {
1163             Eina.Size2D _ret_var = default(Eina.Size2D);
1164                 try
1165                 {
1166                     _ret_var = ((IHint)wrapper).GetHintSizeRestrictedMin();
1167                 }
1168                 catch (Exception e)
1169                 {
1170                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1171                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1172                 }
1173
1174         return _ret_var;
1175
1176             }
1177             else
1178             {
1179                 return efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1180             }
1181         }
1182
1183         private static efl_gfx_hint_size_restricted_min_get_delegate efl_gfx_hint_size_restricted_min_get_static_delegate;
1184
1185
1186         private delegate void efl_gfx_hint_size_restricted_min_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct sz);
1187
1188
1189         public delegate void efl_gfx_hint_size_restricted_min_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct sz);
1190
1191         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_restricted_min_set_api_delegate> efl_gfx_hint_size_restricted_min_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_restricted_min_set_api_delegate>(Module, "efl_gfx_hint_size_restricted_min_set");
1192
1193         private static void hint_size_restricted_min_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct sz)
1194         {
1195             Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_set was called");
1196             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1197             if (wrapper != null)
1198             {
1199         Eina.Size2D _in_sz = sz;
1200
1201                 try
1202                 {
1203                     ((IHint)wrapper).SetHintSizeRestrictedMin(_in_sz);
1204                 }
1205                 catch (Exception e)
1206                 {
1207                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1208                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1209                 }
1210
1211
1212             }
1213             else
1214             {
1215                 efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
1216             }
1217         }
1218
1219         private static efl_gfx_hint_size_restricted_min_set_delegate efl_gfx_hint_size_restricted_min_set_static_delegate;
1220
1221
1222         private delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_combined_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
1223
1224
1225         public delegate Eina.Size2D.NativeStruct efl_gfx_hint_size_combined_min_get_api_delegate(System.IntPtr obj);
1226
1227         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_size_combined_min_get_api_delegate> efl_gfx_hint_size_combined_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_size_combined_min_get_api_delegate>(Module, "efl_gfx_hint_size_combined_min_get");
1228
1229         private static Eina.Size2D.NativeStruct hint_size_combined_min_get(System.IntPtr obj, System.IntPtr pd)
1230         {
1231             Eina.Log.Debug("function efl_gfx_hint_size_combined_min_get was called");
1232             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1233             if (wrapper != null)
1234             {
1235             Eina.Size2D _ret_var = default(Eina.Size2D);
1236                 try
1237                 {
1238                     _ret_var = ((IHint)wrapper).GetHintSizeCombinedMin();
1239                 }
1240                 catch (Exception e)
1241                 {
1242                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1243                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1244                 }
1245
1246         return _ret_var;
1247
1248             }
1249             else
1250             {
1251                 return efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1252             }
1253         }
1254
1255         private static efl_gfx_hint_size_combined_min_get_delegate efl_gfx_hint_size_combined_min_get_static_delegate;
1256
1257
1258         private delegate void efl_gfx_hint_margin_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b);
1259
1260
1261         public delegate void efl_gfx_hint_margin_get_api_delegate(System.IntPtr obj,  out int l,  out int r,  out int t,  out int b);
1262
1263         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_margin_get_api_delegate> efl_gfx_hint_margin_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_margin_get_api_delegate>(Module, "efl_gfx_hint_margin_get");
1264
1265         private static void hint_margin_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
1266         {
1267             Eina.Log.Debug("function efl_gfx_hint_margin_get was called");
1268             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1269             if (wrapper != null)
1270             {
1271                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
1272                 try
1273                 {
1274                     ((IHint)wrapper).GetHintMargin(out l, out r, out t, out b);
1275                 }
1276                 catch (Exception e)
1277                 {
1278                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1279                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1280                 }
1281
1282
1283             }
1284             else
1285             {
1286                 efl_gfx_hint_margin_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out l, out r, out t, out b);
1287             }
1288         }
1289
1290         private static efl_gfx_hint_margin_get_delegate efl_gfx_hint_margin_get_static_delegate;
1291
1292
1293         private delegate void efl_gfx_hint_margin_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
1294
1295
1296         public delegate void efl_gfx_hint_margin_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
1297
1298         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_margin_set_api_delegate> efl_gfx_hint_margin_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_margin_set_api_delegate>(Module, "efl_gfx_hint_margin_set");
1299
1300         private static void hint_margin_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
1301         {
1302             Eina.Log.Debug("function efl_gfx_hint_margin_set was called");
1303             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1304             if (wrapper != null)
1305             {
1306
1307                 try
1308                 {
1309                     ((IHint)wrapper).SetHintMargin(l, r, t, b);
1310                 }
1311                 catch (Exception e)
1312                 {
1313                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1314                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1315                 }
1316
1317
1318             }
1319             else
1320             {
1321                 efl_gfx_hint_margin_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), l, r, t, b);
1322             }
1323         }
1324
1325         private static efl_gfx_hint_margin_set_delegate efl_gfx_hint_margin_set_static_delegate;
1326
1327
1328         private delegate void efl_gfx_hint_weight_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
1329
1330
1331         public delegate void efl_gfx_hint_weight_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
1332
1333         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_weight_get_api_delegate> efl_gfx_hint_weight_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_weight_get_api_delegate>(Module, "efl_gfx_hint_weight_get");
1334
1335         private static void hint_weight_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
1336         {
1337             Eina.Log.Debug("function efl_gfx_hint_weight_get was called");
1338             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1339             if (wrapper != null)
1340             {
1341                         x = default(double);        y = default(double);
1342                 try
1343                 {
1344                     ((IHint)wrapper).GetHintWeight(out x, out y);
1345                 }
1346                 catch (Exception e)
1347                 {
1348                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1349                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1350                 }
1351
1352
1353             }
1354             else
1355             {
1356                 efl_gfx_hint_weight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
1357             }
1358         }
1359
1360         private static efl_gfx_hint_weight_get_delegate efl_gfx_hint_weight_get_static_delegate;
1361
1362
1363         private delegate void efl_gfx_hint_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
1364
1365
1366         public delegate void efl_gfx_hint_weight_set_api_delegate(System.IntPtr obj,  double x,  double y);
1367
1368         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_weight_set_api_delegate> efl_gfx_hint_weight_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_weight_set_api_delegate>(Module, "efl_gfx_hint_weight_set");
1369
1370         private static void hint_weight_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
1371         {
1372             Eina.Log.Debug("function efl_gfx_hint_weight_set was called");
1373             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1374             if (wrapper != null)
1375             {
1376
1377                 try
1378                 {
1379                     ((IHint)wrapper).SetHintWeight(x, y);
1380                 }
1381                 catch (Exception e)
1382                 {
1383                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1384                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1385                 }
1386
1387
1388             }
1389             else
1390             {
1391                 efl_gfx_hint_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1392             }
1393         }
1394
1395         private static efl_gfx_hint_weight_set_delegate efl_gfx_hint_weight_set_static_delegate;
1396
1397
1398         private delegate void efl_gfx_hint_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
1399
1400
1401         public delegate void efl_gfx_hint_align_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
1402
1403         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_align_get_api_delegate> efl_gfx_hint_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_align_get_api_delegate>(Module, "efl_gfx_hint_align_get");
1404
1405         private static void hint_align_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
1406         {
1407             Eina.Log.Debug("function efl_gfx_hint_align_get was called");
1408             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1409             if (wrapper != null)
1410             {
1411                         x = default(double);        y = default(double);
1412                 try
1413                 {
1414                     ((IHint)wrapper).GetHintAlign(out x, out y);
1415                 }
1416                 catch (Exception e)
1417                 {
1418                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1419                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1420                 }
1421
1422
1423             }
1424             else
1425             {
1426                 efl_gfx_hint_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
1427             }
1428         }
1429
1430         private static efl_gfx_hint_align_get_delegate efl_gfx_hint_align_get_static_delegate;
1431
1432
1433         private delegate void efl_gfx_hint_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
1434
1435
1436         public delegate void efl_gfx_hint_align_set_api_delegate(System.IntPtr obj,  double x,  double y);
1437
1438         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_align_set_api_delegate> efl_gfx_hint_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_align_set_api_delegate>(Module, "efl_gfx_hint_align_set");
1439
1440         private static void hint_align_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
1441         {
1442             Eina.Log.Debug("function efl_gfx_hint_align_set was called");
1443             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1444             if (wrapper != null)
1445             {
1446
1447                 try
1448                 {
1449                     ((IHint)wrapper).SetHintAlign(x, y);
1450                 }
1451                 catch (Exception e)
1452                 {
1453                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1454                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1455                 }
1456
1457
1458             }
1459             else
1460             {
1461                 efl_gfx_hint_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1462             }
1463         }
1464
1465         private static efl_gfx_hint_align_set_delegate efl_gfx_hint_align_set_static_delegate;
1466
1467
1468         private delegate void efl_gfx_hint_fill_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] out bool x, [MarshalAs(UnmanagedType.U1)] out bool y);
1469
1470
1471         public delegate void efl_gfx_hint_fill_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] out bool x, [MarshalAs(UnmanagedType.U1)] out bool y);
1472
1473         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_fill_get_api_delegate> efl_gfx_hint_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_fill_get_api_delegate>(Module, "efl_gfx_hint_fill_get");
1474
1475         private static void hint_fill_get(System.IntPtr obj, System.IntPtr pd, out bool x, out bool y)
1476         {
1477             Eina.Log.Debug("function efl_gfx_hint_fill_get was called");
1478             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1479             if (wrapper != null)
1480             {
1481                         x = default(bool);        y = default(bool);
1482                 try
1483                 {
1484                     ((IHint)wrapper).GetHintFill(out x, out y);
1485                 }
1486                 catch (Exception e)
1487                 {
1488                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1489                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1490                 }
1491
1492
1493             }
1494             else
1495             {
1496                 efl_gfx_hint_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
1497             }
1498         }
1499
1500         private static efl_gfx_hint_fill_get_delegate efl_gfx_hint_fill_get_static_delegate;
1501
1502
1503         private delegate void efl_gfx_hint_fill_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool x, [MarshalAs(UnmanagedType.U1)] bool y);
1504
1505
1506         public delegate void efl_gfx_hint_fill_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool x, [MarshalAs(UnmanagedType.U1)] bool y);
1507
1508         public static Efl.Eo.FunctionWrapper<efl_gfx_hint_fill_set_api_delegate> efl_gfx_hint_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_hint_fill_set_api_delegate>(Module, "efl_gfx_hint_fill_set");
1509
1510         private static void hint_fill_set(System.IntPtr obj, System.IntPtr pd, bool x, bool y)
1511         {
1512             Eina.Log.Debug("function efl_gfx_hint_fill_set was called");
1513             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1514             if (wrapper != null)
1515             {
1516
1517                 try
1518                 {
1519                     ((IHint)wrapper).SetHintFill(x, y);
1520                 }
1521                 catch (Exception e)
1522                 {
1523                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1524                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1525                 }
1526
1527
1528             }
1529             else
1530             {
1531                 efl_gfx_hint_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1532             }
1533         }
1534
1535         private static efl_gfx_hint_fill_set_delegate efl_gfx_hint_fill_set_static_delegate;
1536
1537         #pragma warning restore CA1707, SA1300, SA1600
1538
1539 }
1540 }
1541 }
1542
1543 }
1544