internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl { namespace Gfx {
   8 public partial class Constants {
   9    public static readonly double HintExpand = 1.000000;
  10 }
  11 } }
  12 namespace Efl { namespace Gfx {
  13 /// <summary>Efl graphics hint interface</summary>
  14 [HintNativeInherit]
  15 public interface Hint :
  16    Efl.Eo.IWrapper, IDisposable
  17 {
  18    /// <summary>Defines the aspect ratio to respect when scaling this object.
  19 /// 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.
  20 ///
  21 /// 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.</summary>
  22 /// <param name="mode">Mode of interpretation.</param>
  23 /// <param name="sz">Base size to use for aspecting.</param>
  24 /// <returns></returns>
  25  void GetHintAspect( out Efl.Gfx.HintAspect mode,  out Eina.Size2D sz);
  26    /// <summary>Defines the aspect ratio to respect when scaling this object.
  27 /// 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.
  28 ///
  29 /// 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.</summary>
  30 /// <param name="mode">Mode of interpretation.</param>
  31 /// <param name="sz">Base size to use for aspecting.</param>
  32 /// <returns></returns>
  33  void SetHintAspect( Efl.Gfx.HintAspect mode,  Eina.Size2D sz);
  34    /// <summary>Hints on the object&apos;s maximum size.
  35 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  36 ///
  37 /// The object container is in charge of fetching this property and placing the object accordingly.
  38 ///
  39 /// Values -1 will be treated as unset hint components, when queried by managers.
  40 ///
  41 /// 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.</summary>
  42 /// <returns>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</returns>
  43 Eina.Size2D GetHintSizeMax();
  44    /// <summary>Hints on the object&apos;s maximum size.
  45 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  46 ///
  47 /// The object container is in charge of fetching this property and placing the object accordingly.
  48 ///
  49 /// Values -1 will be treated as unset hint components, when queried by managers.
  50 ///
  51 /// 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.</summary>
  52 /// <param name="sz">Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</param>
  53 /// <returns></returns>
  54  void SetHintSizeMax( Eina.Size2D sz);
  55    /// <summary>Hints on the object&apos;s minimum size.
  56 /// 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.
  57 ///
  58 /// Value 0 will be treated as unset hint components, when queried by managers.
  59 ///
  60 /// 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).</summary>
  61 /// <returns>Minimum size (hint) in pixels.</returns>
  62 Eina.Size2D GetHintSizeMin();
  63    /// <summary>Hints on the object&apos;s minimum size.
  64 /// 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.
  65 ///
  66 /// Value 0 will be treated as unset hint components, when queried by managers.
  67 ///
  68 /// 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).</summary>
  69 /// <param name="sz">Minimum size (hint) in pixels.</param>
  70 /// <returns></returns>
  71  void SetHintSizeMin( Eina.Size2D sz);
  72    /// <summary>Get the &quot;intrinsic&quot; minimum size of this object.</summary>
  73 /// <returns>Minimum size (hint) in pixels.</returns>
  74 Eina.Size2D GetHintSizeRestrictedMin();
  75    /// <summary>This function is protected as it is meant for widgets to indicate their &quot;intrinsic&quot; minimum size.</summary>
  76 /// <param name="sz">Minimum size (hint) in pixels.</param>
  77 /// <returns></returns>
  78  void SetHintSizeRestrictedMin( Eina.Size2D sz);
  79    /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.Hint.HintSizeMin"/> hints.
  80 /// <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.Hint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.Hint.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.</summary>
  81 /// <returns>Minimum size (hint) in pixels.</returns>
  82 Eina.Size2D GetHintSizeCombinedMin();
  83    /// <summary>Hints for an object&apos;s margin or padding space.
  84 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  85 ///
  86 /// The object container is in charge of fetching this property and placing the object accordingly.
  87 ///
  88 /// 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.</summary>
  89 /// <param name="l">Integer to specify left padding.</param>
  90 /// <param name="r">Integer to specify right padding.</param>
  91 /// <param name="t">Integer to specify top padding.</param>
  92 /// <param name="b">Integer to specify bottom padding.</param>
  93 /// <returns></returns>
  94  void GetHintMargin( out  int l,  out  int r,  out  int t,  out  int b);
  95    /// <summary>Hints for an object&apos;s margin or padding space.
  96 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
  97 ///
  98 /// The object container is in charge of fetching this property and placing the object accordingly.
  99 ///
 100 /// 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.</summary>
 101 /// <param name="l">Integer to specify left padding.</param>
 102 /// <param name="r">Integer to specify right padding.</param>
 103 /// <param name="t">Integer to specify top padding.</param>
 104 /// <param name="b">Integer to specify bottom padding.</param>
 105 /// <returns></returns>
 106  void SetHintMargin(  int l,   int r,   int t,   int b);
 107    /// <summary>Hints for an object&apos;s weight.
 108 /// 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.
 109 ///
 110 /// 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.
 111 ///
 112 /// Note: Default weight hint values are 0.0, for both axis.</summary>
 113 /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 114 /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 115 /// <returns></returns>
 116  void GetHintWeight( out double x,  out double y);
 117    /// <summary>Hints for an object&apos;s weight.
 118 /// 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.
 119 ///
 120 /// 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.
 121 ///
 122 /// Note: Default weight hint values are 0.0, for both axis.</summary>
 123 /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 124 /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 125 /// <returns></returns>
 126  void SetHintWeight( double x,  double y);
 127    /// <summary>Hints for an object&apos;s alignment.
 128 /// 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.
 129 ///
 130 /// 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.
 131 ///
 132 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 133 ///
 134 /// Note: Default alignment hint values are 0.5, for both axes.</summary>
 135 /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 136 /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 137 /// <returns></returns>
 138  void GetHintAlign( out double x,  out double y);
 139    /// <summary>Hints for an object&apos;s alignment.
 140 /// 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.
 141 ///
 142 /// 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.
 143 ///
 144 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 145 ///
 146 /// Note: Default alignment hint values are 0.5, for both axes.</summary>
 147 /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 148 /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 149 /// <returns></returns>
 150  void SetHintAlign( double x,  double y);
 151    /// <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.Hint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 152 /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.Hint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 153 ///
 154 /// 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.
 155 ///
 156 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 157 ///
 158 /// Note: Default fill hint values are true, for both axes.</summary>
 159 /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 160 /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 161 /// <returns></returns>
 162  void GetHintFill( out bool x,  out bool y);
 163    /// <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.Hint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 164 /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.Hint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 165 ///
 166 /// 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.
 167 ///
 168 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 169 ///
 170 /// Note: Default fill hint values are true, for both axes.</summary>
 171 /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 172 /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 173 /// <returns></returns>
 174  void SetHintFill( bool x,  bool y);
 175                                                       /// <summary>Object hints changed.</summary>
 176    event EventHandler HintsChangedEvt;
 177    /// <summary>Hints on the object&apos;s maximum size.
 178 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 179 ///
 180 /// The object container is in charge of fetching this property and placing the object accordingly.
 181 ///
 182 /// Values -1 will be treated as unset hint components, when queried by managers.
 183 ///
 184 /// 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.</summary>
 185 /// <value>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</value>
 186    Eina.Size2D HintSizeMax {
 187       get ;
 188       set ;
 189    }
 190    /// <summary>Hints on the object&apos;s minimum size.
 191 /// 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.
 192 ///
 193 /// Value 0 will be treated as unset hint components, when queried by managers.
 194 ///
 195 /// 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).</summary>
 196 /// <value>Minimum size (hint) in pixels.</value>
 197    Eina.Size2D HintSizeMin {
 198       get ;
 199       set ;
 200    }
 201    /// <summary>Internal hints for an object&apos;s minimum size.
 202 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 203 ///
 204 /// Values 0 will be treated as unset hint components, when queried by managers.
 205 ///
 206 /// 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.Hint.HintSizeMin"/> instead.</summary>
 207 /// <value>Minimum size (hint) in pixels.</value>
 208    Eina.Size2D HintSizeRestrictedMin {
 209       get ;
 210       set ;
 211    }
 212    /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.Hint.HintSizeMin"/> hints.
 213 /// <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.Hint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.Hint.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.</summary>
 214 /// <value>Minimum size (hint) in pixels.</value>
 215    Eina.Size2D HintSizeCombinedMin {
 216       get ;
 217    }
 218 }
 219 /// <summary>Efl graphics hint interface</summary>
 220 sealed public class HintConcrete :
 221
 222 Hint
 223
 224 {
 225    ///<summary>Pointer to the native class description.</summary>
 226    public System.IntPtr NativeClass {
 227       get {
 228          if (((object)this).GetType() == typeof (HintConcrete))
 229             return Efl.Gfx.HintNativeInherit.GetEflClassStatic();
 230          else
 231             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 232       }
 233    }
 234    private EventHandlerList eventHandlers = new EventHandlerList();
 235    private  System.IntPtr handle;
 236    ///<summary>Pointer to the native instance.</summary>
 237    public System.IntPtr NativeHandle {
 238       get { return handle; }
 239    }
 240    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 241       efl_gfx_hint_interface_get();
 242    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 243    public HintConcrete(System.IntPtr raw)
 244    {
 245       handle = raw;
 246       register_event_proxies();
 247    }
 248    ///<summary>Destructor.</summary>
 249    ~HintConcrete()
 250    {
 251       Dispose(false);
 252    }
 253    ///<summary>Releases the underlying native instance.</summary>
 254    void Dispose(bool disposing)
 255    {
 256       if (handle != System.IntPtr.Zero) {
 257          Efl.Eo.Globals.efl_unref(handle);
 258          handle = System.IntPtr.Zero;
 259       }
 260    }
 261    ///<summary>Releases the underlying native instance.</summary>
 262    public void Dispose()
 263    {
 264       Dispose(true);
 265       GC.SuppressFinalize(this);
 266    }
 267    ///<summary>Casts obj into an instance of this type.</summary>
 268    public static HintConcrete static_cast(Efl.Object obj)
 269    {
 270       if (obj == null)
 271          throw new System.ArgumentNullException("obj");
 272       return new HintConcrete(obj.NativeHandle);
 273    }
 274    ///<summary>Verifies if the given object is equal to this one.</summary>
 275    public override bool Equals(object obj)
 276    {
 277       var other = obj as Efl.Object;
 278       if (other == null)
 279          return false;
 280       return this.NativeHandle == other.NativeHandle;
 281    }
 282    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 283    public override int GetHashCode()
 284    {
 285       return this.NativeHandle.ToInt32();
 286    }
 287    ///<summary>Turns the native pointer into a string representation.</summary>
 288    public override String ToString()
 289    {
 290       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 291    }
 292    private readonly object eventLock = new object();
 293    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 294    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 295       int event_count = 0;
 296       if (!event_cb_count.TryGetValue(key, out event_count))
 297          event_cb_count[key] = event_count;
 298       if (event_count == 0) {
 299          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 300          if (desc == IntPtr.Zero) {
 301             Eina.Log.Error($"Failed to get native event {key}");
 302             return false;
 303          }
 304           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 305          if (!result) {
 306             Eina.Log.Error($"Failed to add event proxy for event {key}");
 307             return false;
 308          }
 309          Eina.Error.RaiseIfUnhandledException();
 310       }
 311       event_cb_count[key]++;
 312       return true;
 313    }
 314    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 315       int event_count = 0;
 316       if (!event_cb_count.TryGetValue(key, out event_count))
 317          event_cb_count[key] = event_count;
 318       if (event_count == 1) {
 319          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 320          if (desc == IntPtr.Zero) {
 321             Eina.Log.Error($"Failed to get native event {key}");
 322             return false;
 323          }
 324          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 325          if (!result) {
 326             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 327             return false;
 328          }
 329          Eina.Error.RaiseIfUnhandledException();
 330       } else if (event_count == 0) {
 331          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 332          return false;
 333       }
 334       event_cb_count[key]--;
 335       return true;
 336    }
 337 private static object HintsChangedEvtKey = new object();
 338    /// <summary>Object hints changed.</summary>
 339    public event EventHandler HintsChangedEvt
 340    {
 341       add {
 342          lock (eventLock) {
 343             string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
 344             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_HintsChangedEvt_delegate)) {
 345                eventHandlers.AddHandler(HintsChangedEvtKey , value);
 346             } else
 347                Eina.Log.Error($"Error adding proxy for event {key}");
 348          }
 349       }
 350       remove {
 351          lock (eventLock) {
 352             string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
 353             if (remove_cpp_event_handler(key, this.evt_HintsChangedEvt_delegate)) {
 354                eventHandlers.RemoveHandler(HintsChangedEvtKey , value);
 355             } else
 356                Eina.Log.Error($"Error removing proxy for event {key}");
 357          }
 358       }
 359    }
 360    ///<summary>Method to raise event HintsChangedEvt.</summary>
 361    public void On_HintsChangedEvt(EventArgs e)
 362    {
 363       EventHandler evt;
 364       lock (eventLock) {
 365       evt = (EventHandler)eventHandlers[HintsChangedEvtKey];
 366       }
 367       evt?.Invoke(this, e);
 368    }
 369    Efl.EventCb evt_HintsChangedEvt_delegate;
 370    private void on_HintsChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 371    {
 372       EventArgs args = EventArgs.Empty;
 373       try {
 374          On_HintsChangedEvt(args);
 375       } catch (Exception e) {
 376          Eina.Log.Error(e.ToString());
 377          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 378       }
 379    }
 380
 381     void register_event_proxies()
 382    {
 383       evt_HintsChangedEvt_delegate = new Efl.EventCb(on_HintsChangedEvt_NativeCallback);
 384    }
 385    /// <summary>Defines the aspect ratio to respect when scaling this object.
 386    /// 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.
 387    ///
 388    /// 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.</summary>
 389    /// <param name="mode">Mode of interpretation.</param>
 390    /// <param name="sz">Base size to use for aspecting.</param>
 391    /// <returns></returns>
 392    public  void GetHintAspect( out Efl.Gfx.HintAspect mode,  out Eina.Size2D sz) {
 393                          var _out_sz = new Eina.Size2D_StructInternal();
 394                   Efl.Gfx.HintNativeInherit.efl_gfx_hint_aspect_get_ptr.Value.Delegate(this.NativeHandle, out mode,  out _out_sz);
 395       Eina.Error.RaiseIfUnhandledException();
 396             sz = Eina.Size2D_StructConversion.ToManaged(_out_sz);
 397                    }
 398    /// <summary>Defines the aspect ratio to respect when scaling this object.
 399    /// 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.
 400    ///
 401    /// 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.</summary>
 402    /// <param name="mode">Mode of interpretation.</param>
 403    /// <param name="sz">Base size to use for aspecting.</param>
 404    /// <returns></returns>
 405    public  void SetHintAspect( Efl.Gfx.HintAspect mode,  Eina.Size2D sz) {
 406              var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
 407                               Efl.Gfx.HintNativeInherit.efl_gfx_hint_aspect_set_ptr.Value.Delegate(this.NativeHandle, mode,  _in_sz);
 408       Eina.Error.RaiseIfUnhandledException();
 409                                }
 410    /// <summary>Hints on the object&apos;s maximum size.
 411    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 412    ///
 413    /// The object container is in charge of fetching this property and placing the object accordingly.
 414    ///
 415    /// Values -1 will be treated as unset hint components, when queried by managers.
 416    ///
 417    /// 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.</summary>
 418    /// <returns>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</returns>
 419    public Eina.Size2D GetHintSizeMax() {
 420        var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_max_get_ptr.Value.Delegate(this.NativeHandle);
 421       Eina.Error.RaiseIfUnhandledException();
 422       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 423  }
 424    /// <summary>Hints on the object&apos;s maximum size.
 425    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 426    ///
 427    /// The object container is in charge of fetching this property and placing the object accordingly.
 428    ///
 429    /// Values -1 will be treated as unset hint components, when queried by managers.
 430    ///
 431    /// 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.</summary>
 432    /// <param name="sz">Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</param>
 433    /// <returns></returns>
 434    public  void SetHintSizeMax( Eina.Size2D sz) {
 435        var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
 436                   Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_max_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
 437       Eina.Error.RaiseIfUnhandledException();
 438                    }
 439    /// <summary>Hints on the object&apos;s minimum size.
 440    /// 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.
 441    ///
 442    /// Value 0 will be treated as unset hint components, when queried by managers.
 443    ///
 444    /// 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).</summary>
 445    /// <returns>Minimum size (hint) in pixels.</returns>
 446    public Eina.Size2D GetHintSizeMin() {
 447        var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_min_get_ptr.Value.Delegate(this.NativeHandle);
 448       Eina.Error.RaiseIfUnhandledException();
 449       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 450  }
 451    /// <summary>Hints on the object&apos;s minimum size.
 452    /// 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.
 453    ///
 454    /// Value 0 will be treated as unset hint components, when queried by managers.
 455    ///
 456    /// 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).</summary>
 457    /// <param name="sz">Minimum size (hint) in pixels.</param>
 458    /// <returns></returns>
 459    public  void SetHintSizeMin( Eina.Size2D sz) {
 460        var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
 461                   Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_min_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
 462       Eina.Error.RaiseIfUnhandledException();
 463                    }
 464    /// <summary>Get the &quot;intrinsic&quot; minimum size of this object.</summary>
 465    /// <returns>Minimum size (hint) in pixels.</returns>
 466    public Eina.Size2D GetHintSizeRestrictedMin() {
 467        var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(this.NativeHandle);
 468       Eina.Error.RaiseIfUnhandledException();
 469       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 470  }
 471    /// <summary>This function is protected as it is meant for widgets to indicate their &quot;intrinsic&quot; minimum size.</summary>
 472    /// <param name="sz">Minimum size (hint) in pixels.</param>
 473    /// <returns></returns>
 474    public  void SetHintSizeRestrictedMin( Eina.Size2D sz) {
 475        var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
 476                   Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
 477       Eina.Error.RaiseIfUnhandledException();
 478                    }
 479    /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.Hint.HintSizeMin"/> hints.
 480    /// <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.Hint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.Hint.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.</summary>
 481    /// <returns>Minimum size (hint) in pixels.</returns>
 482    public Eina.Size2D GetHintSizeCombinedMin() {
 483        var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(this.NativeHandle);
 484       Eina.Error.RaiseIfUnhandledException();
 485       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 486  }
 487    /// <summary>Hints for an object&apos;s margin or padding space.
 488    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 489    ///
 490    /// The object container is in charge of fetching this property and placing the object accordingly.
 491    ///
 492    /// 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.</summary>
 493    /// <param name="l">Integer to specify left padding.</param>
 494    /// <param name="r">Integer to specify right padding.</param>
 495    /// <param name="t">Integer to specify top padding.</param>
 496    /// <param name="b">Integer to specify bottom padding.</param>
 497    /// <returns></returns>
 498    public  void GetHintMargin( out  int l,  out  int r,  out  int t,  out  int b) {
 499                                                                                Efl.Gfx.HintNativeInherit.efl_gfx_hint_margin_get_ptr.Value.Delegate(this.NativeHandle, out l,  out r,  out t,  out b);
 500       Eina.Error.RaiseIfUnhandledException();
 501                                                        }
 502    /// <summary>Hints for an object&apos;s margin or padding space.
 503    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 504    ///
 505    /// The object container is in charge of fetching this property and placing the object accordingly.
 506    ///
 507    /// 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.</summary>
 508    /// <param name="l">Integer to specify left padding.</param>
 509    /// <param name="r">Integer to specify right padding.</param>
 510    /// <param name="t">Integer to specify top padding.</param>
 511    /// <param name="b">Integer to specify bottom padding.</param>
 512    /// <returns></returns>
 513    public  void SetHintMargin(  int l,   int r,   int t,   int b) {
 514                                                                                Efl.Gfx.HintNativeInherit.efl_gfx_hint_margin_set_ptr.Value.Delegate(this.NativeHandle, l,  r,  t,  b);
 515       Eina.Error.RaiseIfUnhandledException();
 516                                                        }
 517    /// <summary>Hints for an object&apos;s weight.
 518    /// 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.
 519    ///
 520    /// 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.
 521    ///
 522    /// Note: Default weight hint values are 0.0, for both axis.</summary>
 523    /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 524    /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 525    /// <returns></returns>
 526    public  void GetHintWeight( out double x,  out double y) {
 527                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_weight_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 528       Eina.Error.RaiseIfUnhandledException();
 529                                }
 530    /// <summary>Hints for an object&apos;s weight.
 531    /// 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.
 532    ///
 533    /// 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.
 534    ///
 535    /// Note: Default weight hint values are 0.0, for both axis.</summary>
 536    /// <param name="x">Non-negative double value to use as horizontal weight hint.</param>
 537    /// <param name="y">Non-negative double value to use as vertical weight hint.</param>
 538    /// <returns></returns>
 539    public  void SetHintWeight( double x,  double y) {
 540                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_weight_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 541       Eina.Error.RaiseIfUnhandledException();
 542                                }
 543    /// <summary>Hints for an object&apos;s alignment.
 544    /// 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.
 545    ///
 546    /// 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.
 547    ///
 548    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 549    ///
 550    /// Note: Default alignment hint values are 0.5, for both axes.</summary>
 551    /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 552    /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 553    /// <returns></returns>
 554    public  void GetHintAlign( out double x,  out double y) {
 555                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_align_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 556       Eina.Error.RaiseIfUnhandledException();
 557                                }
 558    /// <summary>Hints for an object&apos;s alignment.
 559    /// 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.
 560    ///
 561    /// 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.
 562    ///
 563    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 564    ///
 565    /// Note: Default alignment hint values are 0.5, for both axes.</summary>
 566    /// <param name="x">Double, ranging from 0.0 to 1.0.</param>
 567    /// <param name="y">Double, ranging from 0.0 to 1.0.</param>
 568    /// <returns></returns>
 569    public  void SetHintAlign( double x,  double y) {
 570                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_align_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 571       Eina.Error.RaiseIfUnhandledException();
 572                                }
 573    /// <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.Hint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 574    /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.Hint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 575    ///
 576    /// 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.
 577    ///
 578    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 579    ///
 580    /// Note: Default fill hint values are true, for both axes.</summary>
 581    /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 582    /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 583    /// <returns></returns>
 584    public  void GetHintFill( out bool x,  out bool y) {
 585                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_fill_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 586       Eina.Error.RaiseIfUnhandledException();
 587                                }
 588    /// <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.Hint.GetHintFill"/> specify whether to fill the space inside the boundaries of a container/manager.
 589    /// Maximum hints should be enforced with higher priority, if they are set. Also, any <see cref="Efl.Gfx.Hint.GetHintMargin"/> set on objects should add up to the object space on the final scene composition.
 590    ///
 591    /// 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.
 592    ///
 593    /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 594    ///
 595    /// Note: Default fill hint values are true, for both axes.</summary>
 596    /// <param name="x"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as horizontal fill hint.</param>
 597    /// <param name="y"><c>true</c> if to fill the object space, <c>false</c> otherwise, to use as vertical fill hint.</param>
 598    /// <returns></returns>
 599    public  void SetHintFill( bool x,  bool y) {
 600                                            Efl.Gfx.HintNativeInherit.efl_gfx_hint_fill_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 601       Eina.Error.RaiseIfUnhandledException();
 602                                }
 603    /// <summary>Hints on the object&apos;s maximum size.
 604 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 605 ///
 606 /// The object container is in charge of fetching this property and placing the object accordingly.
 607 ///
 608 /// Values -1 will be treated as unset hint components, when queried by managers.
 609 ///
 610 /// 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.</summary>
 611 /// <value>Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).</value>
 612    public Eina.Size2D HintSizeMax {
 613       get { return GetHintSizeMax(); }
 614       set { SetHintSizeMax( value); }
 615    }
 616    /// <summary>Hints on the object&apos;s minimum size.
 617 /// 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.
 618 ///
 619 /// Value 0 will be treated as unset hint components, when queried by managers.
 620 ///
 621 /// 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).</summary>
 622 /// <value>Minimum size (hint) in pixels.</value>
 623    public Eina.Size2D HintSizeMin {
 624       get { return GetHintSizeMin(); }
 625       set { SetHintSizeMin( value); }
 626    }
 627    /// <summary>Internal hints for an object&apos;s minimum size.
 628 /// This is not a size enforcement in any way, it&apos;s just a hint that should be used whenever appropriate.
 629 ///
 630 /// Values 0 will be treated as unset hint components, when queried by managers.
 631 ///
 632 /// 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.Hint.HintSizeMin"/> instead.</summary>
 633 /// <value>Minimum size (hint) in pixels.</value>
 634    public Eina.Size2D HintSizeRestrictedMin {
 635       get { return GetHintSizeRestrictedMin(); }
 636       set { SetHintSizeRestrictedMin( value); }
 637    }
 638    /// <summary>Read-only minimum size combining both <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> and <see cref="Efl.Gfx.Hint.HintSizeMin"/> hints.
 639 /// <see cref="Efl.Gfx.Hint.HintSizeRestrictedMin"/> is intended for mostly internal usage and widget developers, and <see cref="Efl.Gfx.Hint.HintSizeMin"/> is intended to be set from application side. <see cref="Efl.Gfx.Hint.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.</summary>
 640 /// <value>Minimum size (hint) in pixels.</value>
 641    public Eina.Size2D HintSizeCombinedMin {
 642       get { return GetHintSizeCombinedMin(); }
 643    }
 644 }
 645 public class HintNativeInherit  : Efl.Eo.NativeClass{
 646    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 647    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 648    {
 649       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 650       if (efl_gfx_hint_aspect_get_static_delegate == null)
 651       efl_gfx_hint_aspect_get_static_delegate = new efl_gfx_hint_aspect_get_delegate(hint_aspect_get);
 652       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)});
 653       if (efl_gfx_hint_aspect_set_static_delegate == null)
 654       efl_gfx_hint_aspect_set_static_delegate = new efl_gfx_hint_aspect_set_delegate(hint_aspect_set);
 655       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)});
 656       if (efl_gfx_hint_size_max_get_static_delegate == null)
 657       efl_gfx_hint_size_max_get_static_delegate = new efl_gfx_hint_size_max_get_delegate(hint_size_max_get);
 658       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)});
 659       if (efl_gfx_hint_size_max_set_static_delegate == null)
 660       efl_gfx_hint_size_max_set_static_delegate = new efl_gfx_hint_size_max_set_delegate(hint_size_max_set);
 661       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)});
 662       if (efl_gfx_hint_size_min_get_static_delegate == null)
 663       efl_gfx_hint_size_min_get_static_delegate = new efl_gfx_hint_size_min_get_delegate(hint_size_min_get);
 664       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)});
 665       if (efl_gfx_hint_size_min_set_static_delegate == null)
 666       efl_gfx_hint_size_min_set_static_delegate = new efl_gfx_hint_size_min_set_delegate(hint_size_min_set);
 667       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)});
 668       if (efl_gfx_hint_size_restricted_min_get_static_delegate == null)
 669       efl_gfx_hint_size_restricted_min_get_static_delegate = new efl_gfx_hint_size_restricted_min_get_delegate(hint_size_restricted_min_get);
 670       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)});
 671       if (efl_gfx_hint_size_restricted_min_set_static_delegate == null)
 672       efl_gfx_hint_size_restricted_min_set_static_delegate = new efl_gfx_hint_size_restricted_min_set_delegate(hint_size_restricted_min_set);
 673       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)});
 674       if (efl_gfx_hint_size_combined_min_get_static_delegate == null)
 675       efl_gfx_hint_size_combined_min_get_static_delegate = new efl_gfx_hint_size_combined_min_get_delegate(hint_size_combined_min_get);
 676       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)});
 677       if (efl_gfx_hint_margin_get_static_delegate == null)
 678       efl_gfx_hint_margin_get_static_delegate = new efl_gfx_hint_margin_get_delegate(hint_margin_get);
 679       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)});
 680       if (efl_gfx_hint_margin_set_static_delegate == null)
 681       efl_gfx_hint_margin_set_static_delegate = new efl_gfx_hint_margin_set_delegate(hint_margin_set);
 682       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)});
 683       if (efl_gfx_hint_weight_get_static_delegate == null)
 684       efl_gfx_hint_weight_get_static_delegate = new efl_gfx_hint_weight_get_delegate(hint_weight_get);
 685       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)});
 686       if (efl_gfx_hint_weight_set_static_delegate == null)
 687       efl_gfx_hint_weight_set_static_delegate = new efl_gfx_hint_weight_set_delegate(hint_weight_set);
 688       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)});
 689       if (efl_gfx_hint_align_get_static_delegate == null)
 690       efl_gfx_hint_align_get_static_delegate = new efl_gfx_hint_align_get_delegate(hint_align_get);
 691       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)});
 692       if (efl_gfx_hint_align_set_static_delegate == null)
 693       efl_gfx_hint_align_set_static_delegate = new efl_gfx_hint_align_set_delegate(hint_align_set);
 694       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)});
 695       if (efl_gfx_hint_fill_get_static_delegate == null)
 696       efl_gfx_hint_fill_get_static_delegate = new efl_gfx_hint_fill_get_delegate(hint_fill_get);
 697       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)});
 698       if (efl_gfx_hint_fill_set_static_delegate == null)
 699       efl_gfx_hint_fill_set_static_delegate = new efl_gfx_hint_fill_set_delegate(hint_fill_set);
 700       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)});
 701       return descs;
 702    }
 703    public override IntPtr GetEflClass()
 704    {
 705       return Efl.Gfx.HintConcrete.efl_gfx_hint_interface_get();
 706    }
 707    public static  IntPtr GetEflClassStatic()
 708    {
 709       return Efl.Gfx.HintConcrete.efl_gfx_hint_interface_get();
 710    }
 711
 712
 713     private delegate  void efl_gfx_hint_aspect_get_delegate(System.IntPtr obj, System.IntPtr pd,   out Efl.Gfx.HintAspect mode,   out Eina.Size2D_StructInternal sz);
 714
 715
 716     public delegate  void efl_gfx_hint_aspect_get_api_delegate(System.IntPtr obj,   out Efl.Gfx.HintAspect mode,   out Eina.Size2D_StructInternal sz);
 717     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");
 718     private static  void hint_aspect_get(System.IntPtr obj, System.IntPtr pd,  out Efl.Gfx.HintAspect mode,  out Eina.Size2D_StructInternal sz)
 719    {
 720       Eina.Log.Debug("function efl_gfx_hint_aspect_get was called");
 721       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 722       if(wrapper != null) {
 723                            mode = default(Efl.Gfx.HintAspect);      Eina.Size2D _out_sz = default(Eina.Size2D);
 724
 725          try {
 726             ((Hint)wrapper).GetHintAspect( out mode,  out _out_sz);
 727          } catch (Exception e) {
 728             Eina.Log.Warning($"Callback error: {e.ToString()}");
 729             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 730          }
 731             sz = Eina.Size2D_StructConversion.ToInternal(_out_sz);
 732                         } else {
 733          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);
 734       }
 735    }
 736    private static efl_gfx_hint_aspect_get_delegate efl_gfx_hint_aspect_get_static_delegate;
 737
 738
 739     private delegate  void efl_gfx_hint_aspect_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.HintAspect mode,   Eina.Size2D_StructInternal sz);
 740
 741
 742     public delegate  void efl_gfx_hint_aspect_set_api_delegate(System.IntPtr obj,   Efl.Gfx.HintAspect mode,   Eina.Size2D_StructInternal sz);
 743     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");
 744     private static  void hint_aspect_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.HintAspect mode,  Eina.Size2D_StructInternal sz)
 745    {
 746       Eina.Log.Debug("function efl_gfx_hint_aspect_set was called");
 747       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 748       if(wrapper != null) {
 749                      var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
 750
 751          try {
 752             ((Hint)wrapper).SetHintAspect( mode,  _in_sz);
 753          } catch (Exception e) {
 754             Eina.Log.Warning($"Callback error: {e.ToString()}");
 755             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 756          }
 757                                     } else {
 758          efl_gfx_hint_aspect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mode,  sz);
 759       }
 760    }
 761    private static efl_gfx_hint_aspect_set_delegate efl_gfx_hint_aspect_set_static_delegate;
 762
 763
 764     private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 765
 766
 767     public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_max_get_api_delegate(System.IntPtr obj);
 768     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");
 769     private static Eina.Size2D_StructInternal hint_size_max_get(System.IntPtr obj, System.IntPtr pd)
 770    {
 771       Eina.Log.Debug("function efl_gfx_hint_size_max_get was called");
 772       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 773       if(wrapper != null) {
 774                   Eina.Size2D _ret_var = default(Eina.Size2D);
 775          try {
 776             _ret_var = ((Hint)wrapper).GetHintSizeMax();
 777          } catch (Exception e) {
 778             Eina.Log.Warning($"Callback error: {e.ToString()}");
 779             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 780          }
 781       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 782       } else {
 783          return efl_gfx_hint_size_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 784       }
 785    }
 786    private static efl_gfx_hint_size_max_get_delegate efl_gfx_hint_size_max_get_static_delegate;
 787
 788
 789     private delegate  void efl_gfx_hint_size_max_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal sz);
 790
 791
 792     public delegate  void efl_gfx_hint_size_max_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal sz);
 793     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");
 794     private static  void hint_size_max_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal sz)
 795    {
 796       Eina.Log.Debug("function efl_gfx_hint_size_max_set was called");
 797       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 798       if(wrapper != null) {
 799                var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
 800
 801          try {
 802             ((Hint)wrapper).SetHintSizeMax( _in_sz);
 803          } catch (Exception e) {
 804             Eina.Log.Warning($"Callback error: {e.ToString()}");
 805             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 806          }
 807                         } else {
 808          efl_gfx_hint_size_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sz);
 809       }
 810    }
 811    private static efl_gfx_hint_size_max_set_delegate efl_gfx_hint_size_max_set_static_delegate;
 812
 813
 814     private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 815
 816
 817     public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_min_get_api_delegate(System.IntPtr obj);
 818     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");
 819     private static Eina.Size2D_StructInternal hint_size_min_get(System.IntPtr obj, System.IntPtr pd)
 820    {
 821       Eina.Log.Debug("function efl_gfx_hint_size_min_get was called");
 822       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 823       if(wrapper != null) {
 824                   Eina.Size2D _ret_var = default(Eina.Size2D);
 825          try {
 826             _ret_var = ((Hint)wrapper).GetHintSizeMin();
 827          } catch (Exception e) {
 828             Eina.Log.Warning($"Callback error: {e.ToString()}");
 829             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 830          }
 831       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 832       } else {
 833          return efl_gfx_hint_size_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 834       }
 835    }
 836    private static efl_gfx_hint_size_min_get_delegate efl_gfx_hint_size_min_get_static_delegate;
 837
 838
 839     private delegate  void efl_gfx_hint_size_min_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal sz);
 840
 841
 842     public delegate  void efl_gfx_hint_size_min_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal sz);
 843     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");
 844     private static  void hint_size_min_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal sz)
 845    {
 846       Eina.Log.Debug("function efl_gfx_hint_size_min_set was called");
 847       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 848       if(wrapper != null) {
 849                var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
 850
 851          try {
 852             ((Hint)wrapper).SetHintSizeMin( _in_sz);
 853          } catch (Exception e) {
 854             Eina.Log.Warning($"Callback error: {e.ToString()}");
 855             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 856          }
 857                         } else {
 858          efl_gfx_hint_size_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sz);
 859       }
 860    }
 861    private static efl_gfx_hint_size_min_set_delegate efl_gfx_hint_size_min_set_static_delegate;
 862
 863
 864     private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_restricted_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 865
 866
 867     public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_restricted_min_get_api_delegate(System.IntPtr obj);
 868     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");
 869     private static Eina.Size2D_StructInternal hint_size_restricted_min_get(System.IntPtr obj, System.IntPtr pd)
 870    {
 871       Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_get was called");
 872       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 873       if(wrapper != null) {
 874                   Eina.Size2D _ret_var = default(Eina.Size2D);
 875          try {
 876             _ret_var = ((Hint)wrapper).GetHintSizeRestrictedMin();
 877          } catch (Exception e) {
 878             Eina.Log.Warning($"Callback error: {e.ToString()}");
 879             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 880          }
 881       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 882       } else {
 883          return efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 884       }
 885    }
 886    private static efl_gfx_hint_size_restricted_min_get_delegate efl_gfx_hint_size_restricted_min_get_static_delegate;
 887
 888
 889     private delegate  void efl_gfx_hint_size_restricted_min_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal sz);
 890
 891
 892     public delegate  void efl_gfx_hint_size_restricted_min_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal sz);
 893     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");
 894     private static  void hint_size_restricted_min_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal sz)
 895    {
 896       Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_set was called");
 897       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 898       if(wrapper != null) {
 899                var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
 900
 901          try {
 902             ((Hint)wrapper).SetHintSizeRestrictedMin( _in_sz);
 903          } catch (Exception e) {
 904             Eina.Log.Warning($"Callback error: {e.ToString()}");
 905             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 906          }
 907                         } else {
 908          efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sz);
 909       }
 910    }
 911    private static efl_gfx_hint_size_restricted_min_set_delegate efl_gfx_hint_size_restricted_min_set_static_delegate;
 912
 913
 914     private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_combined_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 915
 916
 917     public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_combined_min_get_api_delegate(System.IntPtr obj);
 918     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");
 919     private static Eina.Size2D_StructInternal hint_size_combined_min_get(System.IntPtr obj, System.IntPtr pd)
 920    {
 921       Eina.Log.Debug("function efl_gfx_hint_size_combined_min_get was called");
 922       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 923       if(wrapper != null) {
 924                   Eina.Size2D _ret_var = default(Eina.Size2D);
 925          try {
 926             _ret_var = ((Hint)wrapper).GetHintSizeCombinedMin();
 927          } catch (Exception e) {
 928             Eina.Log.Warning($"Callback error: {e.ToString()}");
 929             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 930          }
 931       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 932       } else {
 933          return efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 934       }
 935    }
 936    private static efl_gfx_hint_size_combined_min_get_delegate efl_gfx_hint_size_combined_min_get_static_delegate;
 937
 938
 939     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);
 940
 941
 942     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);
 943     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");
 944     private static  void hint_margin_get(System.IntPtr obj, System.IntPtr pd,  out  int l,  out  int r,  out  int t,  out  int b)
 945    {
 946       Eina.Log.Debug("function efl_gfx_hint_margin_get was called");
 947       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 948       if(wrapper != null) {
 949                                        l = default( int);      r = default( int);      t = default( int);      b = default( int);
 950          try {
 951             ((Hint)wrapper).GetHintMargin( out l,  out r,  out t,  out b);
 952          } catch (Exception e) {
 953             Eina.Log.Warning($"Callback error: {e.ToString()}");
 954             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 955          }
 956                                                             } else {
 957          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);
 958       }
 959    }
 960    private static efl_gfx_hint_margin_get_delegate efl_gfx_hint_margin_get_static_delegate;
 961
 962
 963     private delegate  void efl_gfx_hint_margin_set_delegate(System.IntPtr obj, System.IntPtr pd,    int l,    int r,    int t,    int b);
 964
 965
 966     public delegate  void efl_gfx_hint_margin_set_api_delegate(System.IntPtr obj,    int l,    int r,    int t,    int b);
 967     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");
 968     private static  void hint_margin_set(System.IntPtr obj, System.IntPtr pd,   int l,   int r,   int t,   int b)
 969    {
 970       Eina.Log.Debug("function efl_gfx_hint_margin_set was called");
 971       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 972       if(wrapper != null) {
 973
 974          try {
 975             ((Hint)wrapper).SetHintMargin( l,  r,  t,  b);
 976          } catch (Exception e) {
 977             Eina.Log.Warning($"Callback error: {e.ToString()}");
 978             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 979          }
 980                                                             } else {
 981          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);
 982       }
 983    }
 984    private static efl_gfx_hint_margin_set_delegate efl_gfx_hint_margin_set_static_delegate;
 985
 986
 987     private delegate  void efl_gfx_hint_weight_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
 988
 989
 990     public delegate  void efl_gfx_hint_weight_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
 991     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");
 992     private static  void hint_weight_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
 993    {
 994       Eina.Log.Debug("function efl_gfx_hint_weight_get was called");
 995       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 996       if(wrapper != null) {
 997                            x = default(double);      y = default(double);
 998          try {
 999             ((Hint)wrapper).GetHintWeight( out x,  out y);
1000          } catch (Exception e) {
1001             Eina.Log.Warning($"Callback error: {e.ToString()}");
1002             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1003          }
1004                                     } else {
1005          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);
1006       }
1007    }
1008    private static efl_gfx_hint_weight_get_delegate efl_gfx_hint_weight_get_static_delegate;
1009
1010
1011     private delegate  void efl_gfx_hint_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1012
1013
1014     public delegate  void efl_gfx_hint_weight_set_api_delegate(System.IntPtr obj,   double x,   double y);
1015     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");
1016     private static  void hint_weight_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1017    {
1018       Eina.Log.Debug("function efl_gfx_hint_weight_set was called");
1019       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1020       if(wrapper != null) {
1021
1022          try {
1023             ((Hint)wrapper).SetHintWeight( x,  y);
1024          } catch (Exception e) {
1025             Eina.Log.Warning($"Callback error: {e.ToString()}");
1026             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1027          }
1028                                     } else {
1029          efl_gfx_hint_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1030       }
1031    }
1032    private static efl_gfx_hint_weight_set_delegate efl_gfx_hint_weight_set_static_delegate;
1033
1034
1035     private delegate  void efl_gfx_hint_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
1036
1037
1038     public delegate  void efl_gfx_hint_align_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
1039     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");
1040     private static  void hint_align_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
1041    {
1042       Eina.Log.Debug("function efl_gfx_hint_align_get was called");
1043       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1044       if(wrapper != null) {
1045                            x = default(double);      y = default(double);
1046          try {
1047             ((Hint)wrapper).GetHintAlign( out x,  out y);
1048          } catch (Exception e) {
1049             Eina.Log.Warning($"Callback error: {e.ToString()}");
1050             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1051          }
1052                                     } else {
1053          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);
1054       }
1055    }
1056    private static efl_gfx_hint_align_get_delegate efl_gfx_hint_align_get_static_delegate;
1057
1058
1059     private delegate  void efl_gfx_hint_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1060
1061
1062     public delegate  void efl_gfx_hint_align_set_api_delegate(System.IntPtr obj,   double x,   double y);
1063     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");
1064     private static  void hint_align_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1065    {
1066       Eina.Log.Debug("function efl_gfx_hint_align_set was called");
1067       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1068       if(wrapper != null) {
1069
1070          try {
1071             ((Hint)wrapper).SetHintAlign( x,  y);
1072          } catch (Exception e) {
1073             Eina.Log.Warning($"Callback error: {e.ToString()}");
1074             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1075          }
1076                                     } else {
1077          efl_gfx_hint_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1078       }
1079    }
1080    private static efl_gfx_hint_align_set_delegate efl_gfx_hint_align_set_static_delegate;
1081
1082
1083     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);
1084
1085
1086     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);
1087     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");
1088     private static  void hint_fill_get(System.IntPtr obj, System.IntPtr pd,  out bool x,  out bool y)
1089    {
1090       Eina.Log.Debug("function efl_gfx_hint_fill_get was called");
1091       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1092       if(wrapper != null) {
1093                            x = default(bool);      y = default(bool);
1094          try {
1095             ((Hint)wrapper).GetHintFill( out x,  out y);
1096          } catch (Exception e) {
1097             Eina.Log.Warning($"Callback error: {e.ToString()}");
1098             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1099          }
1100                                     } else {
1101          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);
1102       }
1103    }
1104    private static efl_gfx_hint_fill_get_delegate efl_gfx_hint_fill_get_static_delegate;
1105
1106
1107     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);
1108
1109
1110     public delegate  void efl_gfx_hint_fill_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool x,  [MarshalAs(UnmanagedType.U1)]  bool y);
1111     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");
1112     private static  void hint_fill_set(System.IntPtr obj, System.IntPtr pd,  bool x,  bool y)
1113    {
1114       Eina.Log.Debug("function efl_gfx_hint_fill_set was called");
1115       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1116       if(wrapper != null) {
1117
1118          try {
1119             ((Hint)wrapper).SetHintFill( x,  y);
1120          } catch (Exception e) {
1121             Eina.Log.Warning($"Callback error: {e.ToString()}");
1122             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1123          }
1124                                     } else {
1125          efl_gfx_hint_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1126       }
1127    }
1128    private static efl_gfx_hint_fill_set_delegate efl_gfx_hint_fill_set_static_delegate;
1129 }
1130 } }