#pragma warning disable CS1591
using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
namespace Efl { namespace Gfx {
public partial class Constants {
public static readonly double HintExpand = 1.000000;
}
} }
namespace Efl { namespace Gfx {
/// Efl graphics hint interface
[HintNativeInherit]
public interface Hint :
Efl.Eo.IWrapper, IDisposable
{
/// Defines the aspect ratio to respect when scaling this object.
/// 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.
///
/// If any of the given aspect ratio terms are 0, the object's container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
/// Mode of interpretation.
/// Base size to use for aspecting.
///
void GetHintAspect( out Efl.Gfx.HintAspect mode, out Eina.Size2D sz);
/// Defines the aspect ratio to respect when scaling this object.
/// 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.
///
/// If any of the given aspect ratio terms are 0, the object's container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
/// Mode of interpretation.
/// Base size to use for aspecting.
///
void SetHintAspect( Efl.Gfx.HintAspect mode, Eina.Size2D sz);
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
Eina.Size2D GetHintSizeMax();
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
///
void SetHintSizeMax( Eina.Size2D sz);
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
Eina.Size2D GetHintSizeMin();
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
///
void SetHintSizeMin( Eina.Size2D sz);
/// Get the "intrinsic" minimum size of this object.
/// Minimum size (hint) in pixels.
Eina.Size2D GetHintSizeRestrictedMin();
/// This function is protected as it is meant for widgets to indicate their "intrinsic" minimum size.
/// Minimum size (hint) in pixels.
///
void SetHintSizeRestrictedMin( Eina.Size2D sz);
/// Read-only minimum size combining both and hints.
/// is intended for mostly internal usage and widget developers, and is intended to be set from application side. combines both values by taking their repective maximum (in both width and height), and is used internally to get an object's minimum size.
/// Minimum size (hint) in pixels.
Eina.Size2D GetHintSizeCombinedMin();
/// Hints for an object's margin or padding space.
/// This is not a size enforcement in any way, it'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.
///
/// 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.
/// Integer to specify left padding.
/// Integer to specify right padding.
/// Integer to specify top padding.
/// Integer to specify bottom padding.
///
void GetHintMargin( out int l, out int r, out int t, out int b);
/// Hints for an object's margin or padding space.
/// This is not a size enforcement in any way, it'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.
///
/// 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.
/// Integer to specify left padding.
/// Integer to specify right padding.
/// Integer to specify top padding.
/// Integer to specify bottom padding.
///
void SetHintMargin( int l, int r, int t, int b);
/// Hints for an object's weight.
/// 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's dimensions to fit its own (see the helper weight macro) or the complete one of taking each child'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.
///
/// 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.
///
/// Note: Default weight hint values are 0.0, for both axis.
/// Non-negative double value to use as horizontal weight hint.
/// Non-negative double value to use as vertical weight hint.
///
void GetHintWeight( out double x, out double y);
/// Hints for an object's weight.
/// 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's dimensions to fit its own (see the helper weight macro) or the complete one of taking each child'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.
///
/// 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.
///
/// Note: Default weight hint values are 0.0, for both axis.
/// Non-negative double value to use as horizontal weight hint.
/// Non-negative double value to use as vertical weight hint.
///
void SetHintWeight( double x, double y);
/// Hints for an object's alignment.
/// 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.
///
/// 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.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default alignment hint values are 0.5, for both axes.
/// Double, ranging from 0.0 to 1.0.
/// Double, ranging from 0.0 to 1.0.
///
void GetHintAlign( out double x, out double y);
/// Hints for an object's alignment.
/// 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.
///
/// 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.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default alignment hint values are 0.5, for both axes.
/// Double, ranging from 0.0 to 1.0.
/// Double, ranging from 0.0 to 1.0.
///
void SetHintAlign( double x, double y);
/// Hints for an object's fill property that used to specify "justify" or "fill" by some users. specify whether to fill the space inside the boundaries of a container/manager.
/// Maximum hints should be enforced with higher priority, if they are set. Also, any set on objects should add up to the object space on the final scene composition.
///
/// See documentation of possible users: in Evas, they are the "box" and "table" smart objects.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default fill hint values are true, for both axes.
/// true if to fill the object space, false otherwise, to use as horizontal fill hint.
/// true if to fill the object space, false otherwise, to use as vertical fill hint.
///
void GetHintFill( out bool x, out bool y);
/// Hints for an object's fill property that used to specify "justify" or "fill" by some users. specify whether to fill the space inside the boundaries of a container/manager.
/// Maximum hints should be enforced with higher priority, if they are set. Also, any set on objects should add up to the object space on the final scene composition.
///
/// See documentation of possible users: in Evas, they are the "box" and "table" smart objects.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default fill hint values are true, for both axes.
/// true if to fill the object space, false otherwise, to use as horizontal fill hint.
/// true if to fill the object space, false otherwise, to use as vertical fill hint.
///
void SetHintFill( bool x, bool y);
/// Object hints changed.
event EventHandler HintsChangedEvt;
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
Eina.Size2D HintSizeMax {
get ;
set ;
}
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
Eina.Size2D HintSizeMin {
get ;
set ;
}
/// Internal hints for an object's minimum size.
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Values 0 will be treated as unset hint components, when queried by managers.
///
/// 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 instead.
/// Minimum size (hint) in pixels.
Eina.Size2D HintSizeRestrictedMin {
get ;
set ;
}
/// Read-only minimum size combining both and hints.
/// is intended for mostly internal usage and widget developers, and is intended to be set from application side. combines both values by taking their repective maximum (in both width and height), and is used internally to get an object's minimum size.
/// Minimum size (hint) in pixels.
Eina.Size2D HintSizeCombinedMin {
get ;
}
}
/// Efl graphics hint interface
sealed public class HintConcrete :
Hint
{
///Pointer to the native class description.
public System.IntPtr NativeClass {
get {
if (((object)this).GetType() == typeof (HintConcrete))
return Efl.Gfx.HintNativeInherit.GetEflClassStatic();
else
return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
}
}
private EventHandlerList eventHandlers = new EventHandlerList();
private System.IntPtr handle;
///Pointer to the native instance.
public System.IntPtr NativeHandle {
get { return handle; }
}
[System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
efl_gfx_hint_interface_get();
///Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.
public HintConcrete(System.IntPtr raw)
{
handle = raw;
register_event_proxies();
}
///Destructor.
~HintConcrete()
{
Dispose(false);
}
///Releases the underlying native instance.
void Dispose(bool disposing)
{
if (handle != System.IntPtr.Zero) {
Efl.Eo.Globals.efl_unref(handle);
handle = System.IntPtr.Zero;
}
}
///Releases the underlying native instance.
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
///Casts obj into an instance of this type.
public static HintConcrete static_cast(Efl.Object obj)
{
if (obj == null)
throw new System.ArgumentNullException("obj");
return new HintConcrete(obj.NativeHandle);
}
///Verifies if the given object is equal to this one.
public override bool Equals(object obj)
{
var other = obj as Efl.Object;
if (other == null)
return false;
return this.NativeHandle == other.NativeHandle;
}
///Gets the hash code for this object based on the native pointer it points to.
public override int GetHashCode()
{
return this.NativeHandle.ToInt32();
}
///Turns the native pointer into a string representation.
public override String ToString()
{
return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
}
private readonly object eventLock = new object();
private Dictionary event_cb_count = new Dictionary();
private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
int event_count = 0;
if (!event_cb_count.TryGetValue(key, out event_count))
event_cb_count[key] = event_count;
if (event_count == 0) {
IntPtr desc = Efl.EventDescription.GetNative(lib, key);
if (desc == IntPtr.Zero) {
Eina.Log.Error($"Failed to get native event {key}");
return false;
}
bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
if (!result) {
Eina.Log.Error($"Failed to add event proxy for event {key}");
return false;
}
Eina.Error.RaiseIfUnhandledException();
}
event_cb_count[key]++;
return true;
}
private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
int event_count = 0;
if (!event_cb_count.TryGetValue(key, out event_count))
event_cb_count[key] = event_count;
if (event_count == 1) {
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
if (desc == IntPtr.Zero) {
Eina.Log.Error($"Failed to get native event {key}");
return false;
}
bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
if (!result) {
Eina.Log.Error($"Failed to remove event proxy for event {key}");
return false;
}
Eina.Error.RaiseIfUnhandledException();
} else if (event_count == 0) {
Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
return false;
}
event_cb_count[key]--;
return true;
}
private static object HintsChangedEvtKey = new object();
/// Object hints changed.
public event EventHandler HintsChangedEvt
{
add {
lock (eventLock) {
string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_HintsChangedEvt_delegate)) {
eventHandlers.AddHandler(HintsChangedEvtKey , value);
} else
Eina.Log.Error($"Error adding proxy for event {key}");
}
}
remove {
lock (eventLock) {
string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
if (remove_cpp_event_handler(key, this.evt_HintsChangedEvt_delegate)) {
eventHandlers.RemoveHandler(HintsChangedEvtKey , value);
} else
Eina.Log.Error($"Error removing proxy for event {key}");
}
}
}
///Method to raise event HintsChangedEvt.
public void On_HintsChangedEvt(EventArgs e)
{
EventHandler evt;
lock (eventLock) {
evt = (EventHandler)eventHandlers[HintsChangedEvtKey];
}
evt?.Invoke(this, e);
}
Efl.EventCb evt_HintsChangedEvt_delegate;
private void on_HintsChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
{
EventArgs args = EventArgs.Empty;
try {
On_HintsChangedEvt(args);
} catch (Exception e) {
Eina.Log.Error(e.ToString());
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
void register_event_proxies()
{
evt_HintsChangedEvt_delegate = new Efl.EventCb(on_HintsChangedEvt_NativeCallback);
}
/// Defines the aspect ratio to respect when scaling this object.
/// 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.
///
/// If any of the given aspect ratio terms are 0, the object's container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
/// Mode of interpretation.
/// Base size to use for aspecting.
///
public void GetHintAspect( out Efl.Gfx.HintAspect mode, out Eina.Size2D sz) {
var _out_sz = new Eina.Size2D_StructInternal();
Efl.Gfx.HintNativeInherit.efl_gfx_hint_aspect_get_ptr.Value.Delegate(this.NativeHandle, out mode, out _out_sz);
Eina.Error.RaiseIfUnhandledException();
sz = Eina.Size2D_StructConversion.ToManaged(_out_sz);
}
/// Defines the aspect ratio to respect when scaling this object.
/// 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.
///
/// If any of the given aspect ratio terms are 0, the object's container will ignore the aspect and scale this object to occupy the whole available area, for any given policy.
/// Mode of interpretation.
/// Base size to use for aspecting.
///
public void SetHintAspect( Efl.Gfx.HintAspect mode, Eina.Size2D sz) {
var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
Efl.Gfx.HintNativeInherit.efl_gfx_hint_aspect_set_ptr.Value.Delegate(this.NativeHandle, mode, _in_sz);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
public Eina.Size2D GetHintSizeMax() {
var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_max_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return Eina.Size2D_StructConversion.ToManaged(_ret_var);
}
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
///
public void SetHintSizeMax( Eina.Size2D sz) {
var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_max_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
public Eina.Size2D GetHintSizeMin() {
var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_min_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return Eina.Size2D_StructConversion.ToManaged(_ret_var);
}
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
///
public void SetHintSizeMin( Eina.Size2D sz) {
var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_min_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
Eina.Error.RaiseIfUnhandledException();
}
/// Get the "intrinsic" minimum size of this object.
/// Minimum size (hint) in pixels.
public Eina.Size2D GetHintSizeRestrictedMin() {
var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return Eina.Size2D_StructConversion.ToManaged(_ret_var);
}
/// This function is protected as it is meant for widgets to indicate their "intrinsic" minimum size.
/// Minimum size (hint) in pixels.
///
public void SetHintSizeRestrictedMin( Eina.Size2D sz) {
var _in_sz = Eina.Size2D_StructConversion.ToInternal(sz);
Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(this.NativeHandle, _in_sz);
Eina.Error.RaiseIfUnhandledException();
}
/// Read-only minimum size combining both and hints.
/// is intended for mostly internal usage and widget developers, and is intended to be set from application side. combines both values by taking their repective maximum (in both width and height), and is used internally to get an object's minimum size.
/// Minimum size (hint) in pixels.
public Eina.Size2D GetHintSizeCombinedMin() {
var _ret_var = Efl.Gfx.HintNativeInherit.efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return Eina.Size2D_StructConversion.ToManaged(_ret_var);
}
/// Hints for an object's margin or padding space.
/// This is not a size enforcement in any way, it'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.
///
/// 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.
/// Integer to specify left padding.
/// Integer to specify right padding.
/// Integer to specify top padding.
/// Integer to specify bottom padding.
///
public void GetHintMargin( out int l, out int r, out int t, out int b) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_margin_get_ptr.Value.Delegate(this.NativeHandle, out l, out r, out t, out b);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's margin or padding space.
/// This is not a size enforcement in any way, it'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.
///
/// 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.
/// Integer to specify left padding.
/// Integer to specify right padding.
/// Integer to specify top padding.
/// Integer to specify bottom padding.
///
public void SetHintMargin( int l, int r, int t, int b) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_margin_set_ptr.Value.Delegate(this.NativeHandle, l, r, t, b);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's weight.
/// 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's dimensions to fit its own (see the helper weight macro) or the complete one of taking each child'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.
///
/// 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.
///
/// Note: Default weight hint values are 0.0, for both axis.
/// Non-negative double value to use as horizontal weight hint.
/// Non-negative double value to use as vertical weight hint.
///
public void GetHintWeight( out double x, out double y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_weight_get_ptr.Value.Delegate(this.NativeHandle, out x, out y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's weight.
/// 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's dimensions to fit its own (see the helper weight macro) or the complete one of taking each child'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.
///
/// 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.
///
/// Note: Default weight hint values are 0.0, for both axis.
/// Non-negative double value to use as horizontal weight hint.
/// Non-negative double value to use as vertical weight hint.
///
public void SetHintWeight( double x, double y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_weight_set_ptr.Value.Delegate(this.NativeHandle, x, y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's alignment.
/// 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.
///
/// 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.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default alignment hint values are 0.5, for both axes.
/// Double, ranging from 0.0 to 1.0.
/// Double, ranging from 0.0 to 1.0.
///
public void GetHintAlign( out double x, out double y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_align_get_ptr.Value.Delegate(this.NativeHandle, out x, out y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's alignment.
/// 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.
///
/// 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.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default alignment hint values are 0.5, for both axes.
/// Double, ranging from 0.0 to 1.0.
/// Double, ranging from 0.0 to 1.0.
///
public void SetHintAlign( double x, double y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_align_set_ptr.Value.Delegate(this.NativeHandle, x, y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's fill property that used to specify "justify" or "fill" by some users. specify whether to fill the space inside the boundaries of a container/manager.
/// Maximum hints should be enforced with higher priority, if they are set. Also, any set on objects should add up to the object space on the final scene composition.
///
/// See documentation of possible users: in Evas, they are the "box" and "table" smart objects.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default fill hint values are true, for both axes.
/// true if to fill the object space, false otherwise, to use as horizontal fill hint.
/// true if to fill the object space, false otherwise, to use as vertical fill hint.
///
public void GetHintFill( out bool x, out bool y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_fill_get_ptr.Value.Delegate(this.NativeHandle, out x, out y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints for an object's fill property that used to specify "justify" or "fill" by some users. specify whether to fill the space inside the boundaries of a container/manager.
/// Maximum hints should be enforced with higher priority, if they are set. Also, any set on objects should add up to the object space on the final scene composition.
///
/// See documentation of possible users: in Evas, they are the "box" and "table" smart objects.
///
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Note: Default fill hint values are true, for both axes.
/// true if to fill the object space, false otherwise, to use as horizontal fill hint.
/// true if to fill the object space, false otherwise, to use as vertical fill hint.
///
public void SetHintFill( bool x, bool y) {
Efl.Gfx.HintNativeInherit.efl_gfx_hint_fill_set_ptr.Value.Delegate(this.NativeHandle, x, y);
Eina.Error.RaiseIfUnhandledException();
}
/// Hints on the object's maximum size.
/// This is not a size enforcement in any way, it'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.
///
/// Values -1 will be treated as unset hint components, when queried by managers.
///
/// 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.
/// Maximum size (hint) in pixels, (-1, -1) by default for canvas objects).
public Eina.Size2D HintSizeMax {
get { return GetHintSizeMax(); }
set { SetHintSizeMax( value); }
}
/// Hints on the object's minimum size.
/// This is not a size enforcement in any way, it'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.
///
/// Value 0 will be treated as unset hint components, when queried by managers.
///
/// 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).
/// Minimum size (hint) in pixels.
public Eina.Size2D HintSizeMin {
get { return GetHintSizeMin(); }
set { SetHintSizeMin( value); }
}
/// Internal hints for an object's minimum size.
/// This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.
///
/// Values 0 will be treated as unset hint components, when queried by managers.
///
/// 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 instead.
/// Minimum size (hint) in pixels.
public Eina.Size2D HintSizeRestrictedMin {
get { return GetHintSizeRestrictedMin(); }
set { SetHintSizeRestrictedMin( value); }
}
/// Read-only minimum size combining both and hints.
/// is intended for mostly internal usage and widget developers, and is intended to be set from application side. combines both values by taking their repective maximum (in both width and height), and is used internally to get an object's minimum size.
/// Minimum size (hint) in pixels.
public Eina.Size2D HintSizeCombinedMin {
get { return GetHintSizeCombinedMin(); }
}
}
public class HintNativeInherit : Efl.Eo.NativeClass{
public static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
public override System.Collections.Generic.List GetEoOps(System.Type type)
{
var descs = new System.Collections.Generic.List();
if (efl_gfx_hint_aspect_get_static_delegate == null)
efl_gfx_hint_aspect_get_static_delegate = new efl_gfx_hint_aspect_get_delegate(hint_aspect_get);
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)});
if (efl_gfx_hint_aspect_set_static_delegate == null)
efl_gfx_hint_aspect_set_static_delegate = new efl_gfx_hint_aspect_set_delegate(hint_aspect_set);
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)});
if (efl_gfx_hint_size_max_get_static_delegate == null)
efl_gfx_hint_size_max_get_static_delegate = new efl_gfx_hint_size_max_get_delegate(hint_size_max_get);
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)});
if (efl_gfx_hint_size_max_set_static_delegate == null)
efl_gfx_hint_size_max_set_static_delegate = new efl_gfx_hint_size_max_set_delegate(hint_size_max_set);
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)});
if (efl_gfx_hint_size_min_get_static_delegate == null)
efl_gfx_hint_size_min_get_static_delegate = new efl_gfx_hint_size_min_get_delegate(hint_size_min_get);
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)});
if (efl_gfx_hint_size_min_set_static_delegate == null)
efl_gfx_hint_size_min_set_static_delegate = new efl_gfx_hint_size_min_set_delegate(hint_size_min_set);
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)});
if (efl_gfx_hint_size_restricted_min_get_static_delegate == null)
efl_gfx_hint_size_restricted_min_get_static_delegate = new efl_gfx_hint_size_restricted_min_get_delegate(hint_size_restricted_min_get);
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)});
if (efl_gfx_hint_size_restricted_min_set_static_delegate == null)
efl_gfx_hint_size_restricted_min_set_static_delegate = new efl_gfx_hint_size_restricted_min_set_delegate(hint_size_restricted_min_set);
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)});
if (efl_gfx_hint_size_combined_min_get_static_delegate == null)
efl_gfx_hint_size_combined_min_get_static_delegate = new efl_gfx_hint_size_combined_min_get_delegate(hint_size_combined_min_get);
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)});
if (efl_gfx_hint_margin_get_static_delegate == null)
efl_gfx_hint_margin_get_static_delegate = new efl_gfx_hint_margin_get_delegate(hint_margin_get);
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)});
if (efl_gfx_hint_margin_set_static_delegate == null)
efl_gfx_hint_margin_set_static_delegate = new efl_gfx_hint_margin_set_delegate(hint_margin_set);
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)});
if (efl_gfx_hint_weight_get_static_delegate == null)
efl_gfx_hint_weight_get_static_delegate = new efl_gfx_hint_weight_get_delegate(hint_weight_get);
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)});
if (efl_gfx_hint_weight_set_static_delegate == null)
efl_gfx_hint_weight_set_static_delegate = new efl_gfx_hint_weight_set_delegate(hint_weight_set);
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)});
if (efl_gfx_hint_align_get_static_delegate == null)
efl_gfx_hint_align_get_static_delegate = new efl_gfx_hint_align_get_delegate(hint_align_get);
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)});
if (efl_gfx_hint_align_set_static_delegate == null)
efl_gfx_hint_align_set_static_delegate = new efl_gfx_hint_align_set_delegate(hint_align_set);
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)});
if (efl_gfx_hint_fill_get_static_delegate == null)
efl_gfx_hint_fill_get_static_delegate = new efl_gfx_hint_fill_get_delegate(hint_fill_get);
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)});
if (efl_gfx_hint_fill_set_static_delegate == null)
efl_gfx_hint_fill_set_static_delegate = new efl_gfx_hint_fill_set_delegate(hint_fill_set);
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)});
return descs;
}
public override IntPtr GetEflClass()
{
return Efl.Gfx.HintConcrete.efl_gfx_hint_interface_get();
}
public static IntPtr GetEflClassStatic()
{
return Efl.Gfx.HintConcrete.efl_gfx_hint_interface_get();
}
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);
public delegate void efl_gfx_hint_aspect_get_api_delegate(System.IntPtr obj, out Efl.Gfx.HintAspect mode, out Eina.Size2D_StructInternal sz);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_aspect_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_aspect_get");
private static void hint_aspect_get(System.IntPtr obj, System.IntPtr pd, out Efl.Gfx.HintAspect mode, out Eina.Size2D_StructInternal sz)
{
Eina.Log.Debug("function efl_gfx_hint_aspect_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
mode = default(Efl.Gfx.HintAspect); Eina.Size2D _out_sz = default(Eina.Size2D);
try {
((Hint)wrapper).GetHintAspect( out mode, out _out_sz);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
sz = Eina.Size2D_StructConversion.ToInternal(_out_sz);
} else {
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);
}
}
private static efl_gfx_hint_aspect_get_delegate efl_gfx_hint_aspect_get_static_delegate;
private delegate void efl_gfx_hint_aspect_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.HintAspect mode, Eina.Size2D_StructInternal sz);
public delegate void efl_gfx_hint_aspect_set_api_delegate(System.IntPtr obj, Efl.Gfx.HintAspect mode, Eina.Size2D_StructInternal sz);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_aspect_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_aspect_set");
private static void hint_aspect_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.HintAspect mode, Eina.Size2D_StructInternal sz)
{
Eina.Log.Debug("function efl_gfx_hint_aspect_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
try {
((Hint)wrapper).SetHintAspect( mode, _in_sz);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_aspect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode, sz);
}
}
private static efl_gfx_hint_aspect_set_delegate efl_gfx_hint_aspect_set_static_delegate;
private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_max_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_max_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_max_get");
private static Eina.Size2D_StructInternal hint_size_max_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_hint_size_max_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
Eina.Size2D _ret_var = default(Eina.Size2D);
try {
_ret_var = ((Hint)wrapper).GetHintSizeMax();
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return Eina.Size2D_StructConversion.ToInternal(_ret_var);
} else {
return efl_gfx_hint_size_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_hint_size_max_get_delegate efl_gfx_hint_size_max_get_static_delegate;
private delegate void efl_gfx_hint_size_max_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz);
public delegate void efl_gfx_hint_size_max_set_api_delegate(System.IntPtr obj, Eina.Size2D_StructInternal sz);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_max_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_max_set");
private static void hint_size_max_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz)
{
Eina.Log.Debug("function efl_gfx_hint_size_max_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
try {
((Hint)wrapper).SetHintSizeMax( _in_sz);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_size_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
}
}
private static efl_gfx_hint_size_max_set_delegate efl_gfx_hint_size_max_set_static_delegate;
private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_min_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_min_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_min_get");
private static Eina.Size2D_StructInternal hint_size_min_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_hint_size_min_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
Eina.Size2D _ret_var = default(Eina.Size2D);
try {
_ret_var = ((Hint)wrapper).GetHintSizeMin();
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return Eina.Size2D_StructConversion.ToInternal(_ret_var);
} else {
return efl_gfx_hint_size_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_hint_size_min_get_delegate efl_gfx_hint_size_min_get_static_delegate;
private delegate void efl_gfx_hint_size_min_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz);
public delegate void efl_gfx_hint_size_min_set_api_delegate(System.IntPtr obj, Eina.Size2D_StructInternal sz);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_min_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_min_set");
private static void hint_size_min_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz)
{
Eina.Log.Debug("function efl_gfx_hint_size_min_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
try {
((Hint)wrapper).SetHintSizeMin( _in_sz);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_size_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
}
}
private static efl_gfx_hint_size_min_set_delegate efl_gfx_hint_size_min_set_static_delegate;
private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_restricted_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_restricted_min_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_restricted_min_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_restricted_min_get");
private static Eina.Size2D_StructInternal hint_size_restricted_min_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
Eina.Size2D _ret_var = default(Eina.Size2D);
try {
_ret_var = ((Hint)wrapper).GetHintSizeRestrictedMin();
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return Eina.Size2D_StructConversion.ToInternal(_ret_var);
} else {
return efl_gfx_hint_size_restricted_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_hint_size_restricted_min_get_delegate efl_gfx_hint_size_restricted_min_get_static_delegate;
private delegate void efl_gfx_hint_size_restricted_min_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz);
public delegate void efl_gfx_hint_size_restricted_min_set_api_delegate(System.IntPtr obj, Eina.Size2D_StructInternal sz);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_restricted_min_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_restricted_min_set");
private static void hint_size_restricted_min_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D_StructInternal sz)
{
Eina.Log.Debug("function efl_gfx_hint_size_restricted_min_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
var _in_sz = Eina.Size2D_StructConversion.ToManaged(sz);
try {
((Hint)wrapper).SetHintSizeRestrictedMin( _in_sz);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_size_restricted_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
}
}
private static efl_gfx_hint_size_restricted_min_set_delegate efl_gfx_hint_size_restricted_min_set_static_delegate;
private delegate Eina.Size2D_StructInternal efl_gfx_hint_size_combined_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Size2D_StructInternal efl_gfx_hint_size_combined_min_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_size_combined_min_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_size_combined_min_get");
private static Eina.Size2D_StructInternal hint_size_combined_min_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_hint_size_combined_min_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
Eina.Size2D _ret_var = default(Eina.Size2D);
try {
_ret_var = ((Hint)wrapper).GetHintSizeCombinedMin();
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return Eina.Size2D_StructConversion.ToInternal(_ret_var);
} else {
return efl_gfx_hint_size_combined_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_hint_size_combined_min_get_delegate efl_gfx_hint_size_combined_min_get_static_delegate;
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);
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);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_margin_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_margin_get");
private static void hint_margin_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
{
Eina.Log.Debug("function efl_gfx_hint_margin_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
l = default( int); r = default( int); t = default( int); b = default( int);
try {
((Hint)wrapper).GetHintMargin( out l, out r, out t, out b);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
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);
}
}
private static efl_gfx_hint_margin_get_delegate efl_gfx_hint_margin_get_static_delegate;
private delegate void efl_gfx_hint_margin_set_delegate(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b);
public delegate void efl_gfx_hint_margin_set_api_delegate(System.IntPtr obj, int l, int r, int t, int b);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_margin_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_margin_set");
private static void hint_margin_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
{
Eina.Log.Debug("function efl_gfx_hint_margin_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
try {
((Hint)wrapper).SetHintMargin( l, r, t, b);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
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);
}
}
private static efl_gfx_hint_margin_set_delegate efl_gfx_hint_margin_set_static_delegate;
private delegate void efl_gfx_hint_weight_get_delegate(System.IntPtr obj, System.IntPtr pd, out double x, out double y);
public delegate void efl_gfx_hint_weight_get_api_delegate(System.IntPtr obj, out double x, out double y);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_weight_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_weight_get");
private static void hint_weight_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
{
Eina.Log.Debug("function efl_gfx_hint_weight_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
x = default(double); y = default(double);
try {
((Hint)wrapper).GetHintWeight( out x, out y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
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);
}
}
private static efl_gfx_hint_weight_get_delegate efl_gfx_hint_weight_get_static_delegate;
private delegate void efl_gfx_hint_weight_set_delegate(System.IntPtr obj, System.IntPtr pd, double x, double y);
public delegate void efl_gfx_hint_weight_set_api_delegate(System.IntPtr obj, double x, double y);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_weight_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_weight_set");
private static void hint_weight_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
{
Eina.Log.Debug("function efl_gfx_hint_weight_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
try {
((Hint)wrapper).SetHintWeight( x, y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
}
}
private static efl_gfx_hint_weight_set_delegate efl_gfx_hint_weight_set_static_delegate;
private delegate void efl_gfx_hint_align_get_delegate(System.IntPtr obj, System.IntPtr pd, out double x, out double y);
public delegate void efl_gfx_hint_align_get_api_delegate(System.IntPtr obj, out double x, out double y);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_align_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_align_get");
private static void hint_align_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
{
Eina.Log.Debug("function efl_gfx_hint_align_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
x = default(double); y = default(double);
try {
((Hint)wrapper).GetHintAlign( out x, out y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
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);
}
}
private static efl_gfx_hint_align_get_delegate efl_gfx_hint_align_get_static_delegate;
private delegate void efl_gfx_hint_align_set_delegate(System.IntPtr obj, System.IntPtr pd, double x, double y);
public delegate void efl_gfx_hint_align_set_api_delegate(System.IntPtr obj, double x, double y);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_align_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_align_set");
private static void hint_align_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
{
Eina.Log.Debug("function efl_gfx_hint_align_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
try {
((Hint)wrapper).SetHintAlign( x, y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
}
}
private static efl_gfx_hint_align_set_delegate efl_gfx_hint_align_set_static_delegate;
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);
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);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_fill_get_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_fill_get");
private static void hint_fill_get(System.IntPtr obj, System.IntPtr pd, out bool x, out bool y)
{
Eina.Log.Debug("function efl_gfx_hint_fill_get was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
x = default(bool); y = default(bool);
try {
((Hint)wrapper).GetHintFill( out x, out y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
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);
}
}
private static efl_gfx_hint_fill_get_delegate efl_gfx_hint_fill_get_static_delegate;
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);
public delegate void efl_gfx_hint_fill_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool x, [MarshalAs(UnmanagedType.U1)] bool y);
public static Efl.Eo.FunctionWrapper efl_gfx_hint_fill_set_ptr = new Efl.Eo.FunctionWrapper(_Module, "efl_gfx_hint_fill_set");
private static void hint_fill_set(System.IntPtr obj, System.IntPtr pd, bool x, bool y)
{
Eina.Log.Debug("function efl_gfx_hint_fill_set was called");
Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
if(wrapper != null) {
try {
((Hint)wrapper).SetHintFill( x, y);
} catch (Exception e) {
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
} else {
efl_gfx_hint_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
}
}
private static efl_gfx_hint_fill_set_delegate efl_gfx_hint_fill_set_static_delegate;
}
} }