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