#define EFL_BETA
#pragma warning disable CS1591
using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.ComponentModel;
namespace Efl {
namespace Gfx {
/// Common APIs for all 2D images that can be rendered on the canvas.
/// This is a BETA class. It can be modified or removed in the future. Do not use it for product development.
[Efl.Gfx.IImageConcrete.NativeMethods]
[Efl.Eo.BindingEntity]
public interface IImage :
Efl.Eo.IWrapper, IDisposable
{
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
bool GetSmoothScale();
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
void SetSmoothScale(bool smooth_scale);
/// Control how the image is scaled.
/// Image scale type
Efl.Gfx.ImageScaleType GetScaleType();
/// Control how the image is scaled.
/// Image scale type
void SetScaleType(Efl.Gfx.ImageScaleType scale_type);
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
bool GetCanUpscale();
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
void SetCanUpscale(bool upscale);
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
bool GetCanDownscale();
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
void SetCanDownscale(bool downscale);
/// Returns 1.0 if not applicable (eg. height = 0).
/// The image's ratio.
double GetRatio();
/// Return the relative area enclosed inside the image where content is expected.
/// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
///
/// The geometry of the area is expressed relative to the geometry of the object.
/// A rectangle inside the object boundary that where content is expected.
Eina.Rect GetContentRegion();
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
/// The border's right width.
/// The border's top height.
/// The border's bottom height.
void GetBorder(out int l, out int r, out int t, out int b);
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
/// The border's right width.
/// The border's top height.
/// The border's bottom height.
void SetBorder(int l, int r, int t, int b);
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
double GetBorderScale();
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
void SetBorderScale(double scale);
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
Efl.Gfx.BorderFillMode GetBorderCenterFill();
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill);
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
/// Representation of area that are stretchable in the image vertical space.
void GetStretchRegion(out Eina.Iterator horizontal, out Eina.Iterator vertical);
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
/// Representation of area that are stretchable in the image vertical space.
/// return an error code if the stretch_region provided are incorrect.
Eina.Error SetStretchRegion(Eina.Iterator horizontal, Eina.Iterator vertical);
/// This represents the size of the original image in pixels.
/// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
///
/// This is a read-only property, and may return 0x0.
/// The size in pixels.
Eina.Size2D GetImageSize();
/// Get the content hint setting of a given image object of the canvas.
/// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
/// Dynamic or static content hint, see
Efl.Gfx.ImageContentHint GetContentHint();
/// Set the content hint setting of a given image object of the canvas.
/// This function sets the content hint value of the given image of the canvas. For example, if you're on the GL engine and your driver implementation supports it, setting this hint to #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies at texture upload time, which is an "expensive" operation.
/// Dynamic or static content hint, see
void SetContentHint(Efl.Gfx.ImageContentHint hint);
/// Get the scale hint of a given image of the canvas.
/// This function returns the scale hint value of the given image object of the canvas.
/// Scalable or static size hint, see
Efl.Gfx.ImageScaleHint GetScaleHint();
/// Set the scale hint of a given image of the canvas.
/// This function sets the scale hint value of the given image object in the canvas, which will affect how Evas is to cache scaled versions of its original source image.
/// Scalable or static size hint, see
void SetScaleHint(Efl.Gfx.ImageScaleHint hint);
/// Gets the (last) file loading error for a given object.
/// The load error code.
Eina.Error GetImageLoadError();
/// Image data has been preloaded.
event EventHandler ImagePreloadEvt;
/// Image was resized (its pixel data).
event EventHandler ImageResizeEvt;
/// Image data has been unloaded (by some mechanism in EFL that threw out the original image data).
event EventHandler ImageUnloadEvt;
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
bool SmoothScale {
get;
set;
}
/// Control how the image is scaled.
/// Image scale type
Efl.Gfx.ImageScaleType ScaleType {
get;
set;
}
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
bool CanUpscale {
get;
set;
}
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
bool CanDownscale {
get;
set;
}
/// The native width/height ratio of the image.
/// The image's ratio.
double Ratio {
get;
}
/// Return the relative area enclosed inside the image where content is expected.
/// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
///
/// The geometry of the area is expressed relative to the geometry of the object.
/// A rectangle inside the object boundary that where content is expected.
Eina.Rect ContentRegion {
get;
}
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
(int, int, int, int) Border {
get;
set;
}
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
double BorderScale {
get;
set;
}
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
Efl.Gfx.BorderFillMode BorderCenterFill {
get;
set;
}
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
(Eina.Iterator, Eina.Iterator) StretchRegion {
get;
set;
}
/// This represents the size of the original image in pixels.
/// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
///
/// This is a read-only property, and may return 0x0.
/// The size in pixels.
Eina.Size2D ImageSize {
get;
}
/// Get the content hint setting of a given image object of the canvas.
/// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
/// Dynamic or static content hint, see
Efl.Gfx.ImageContentHint ContentHint {
get;
set;
}
/// Get the scale hint of a given image of the canvas.
/// This function returns the scale hint value of the given image object of the canvas.
/// Scalable or static size hint, see
Efl.Gfx.ImageScaleHint ScaleHint {
get;
set;
}
/// Gets the (last) file loading error for a given object.
/// The load error code.
Eina.Error ImageLoadError {
get;
}
}
/// Common APIs for all 2D images that can be rendered on the canvas.
/// This is a BETA class. It can be modified or removed in the future. Do not use it for product development.
sealed public class IImageConcrete :
Efl.Eo.EoWrapper
, IImage
{
/// Pointer to the native class description.
public override System.IntPtr NativeClass
{
get
{
if (((object)this).GetType() == typeof(IImageConcrete))
{
return GetEflClassStatic();
}
else
{
return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
}
}
}
/// Subclasses should override this constructor if they are expected to be instantiated from native code.
/// Do not call this constructor directly.
/// Tag struct storing the native handle of the object being constructed.
private IImageConcrete(ConstructingHandle ch) : base(ch)
{
}
[System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_image_interface_get();
/// Initializes a new instance of the class.
/// Internal usage: This is used when interacting with C code and should not be used directly.
/// The native pointer to be wrapped.
private IImageConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
{
}
/// Image data has been preloaded.
public event EventHandler ImagePreloadEvt
{
add
{
lock (eflBindingEventLock)
{
Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
}
catch (Exception e)
{
Eina.Log.Error(e.ToString());
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
}
}
remove
{
lock (eflBindingEventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
RemoveNativeEventHandler(efl.Libs.Efl, key, value);
}
}
}
/// Method to raise event ImagePreloadEvt.
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
return;
}
Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// Image was resized (its pixel data).
public event EventHandler ImageResizeEvt
{
add
{
lock (eflBindingEventLock)
{
Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
}
catch (Exception e)
{
Eina.Log.Error(e.ToString());
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
}
}
remove
{
lock (eflBindingEventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
RemoveNativeEventHandler(efl.Libs.Efl, key, value);
}
}
}
/// Method to raise event ImageResizeEvt.
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
return;
}
Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// Image data has been unloaded (by some mechanism in EFL that threw out the original image data).
public event EventHandler ImageUnloadEvt
{
add
{
lock (eflBindingEventLock)
{
Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
}
catch (Exception e)
{
Eina.Log.Error(e.ToString());
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
}
}
remove
{
lock (eflBindingEventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
RemoveNativeEventHandler(efl.Libs.Efl, key, value);
}
}
}
/// Method to raise event ImageUnloadEvt.
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
return;
}
Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
public bool GetSmoothScale() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
public void SetSmoothScale(bool smooth_scale) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(this.NativeHandle,smooth_scale);
Eina.Error.RaiseIfUnhandledException();
}
/// Control how the image is scaled.
/// Image scale type
public Efl.Gfx.ImageScaleType GetScaleType() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Control how the image is scaled.
/// Image scale type
public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate(this.NativeHandle,scale_type);
Eina.Error.RaiseIfUnhandledException();
}
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
public bool GetCanUpscale() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
public void SetCanUpscale(bool upscale) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_set_ptr.Value.Delegate(this.NativeHandle,upscale);
Eina.Error.RaiseIfUnhandledException();
}
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
public bool GetCanDownscale() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
public void SetCanDownscale(bool downscale) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_set_ptr.Value.Delegate(this.NativeHandle,downscale);
Eina.Error.RaiseIfUnhandledException();
}
/// Returns 1.0 if not applicable (eg. height = 0).
/// The image's ratio.
public double GetRatio() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_ratio_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Return the relative area enclosed inside the image where content is expected.
/// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
///
/// The geometry of the area is expressed relative to the geometry of the object.
/// A rectangle inside the object boundary that where content is expected.
public Eina.Rect GetContentRegion() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_region_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
/// The border's right width.
/// The border's top height.
/// The border's bottom height.
public void GetBorder(out int l, out int r, out int t, out int b) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_get_ptr.Value.Delegate(this.NativeHandle,out l, out r, out t, out b);
Eina.Error.RaiseIfUnhandledException();
}
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
/// The border's right width.
/// The border's top height.
/// The border's bottom height.
public void SetBorder(int l, int r, int t, int b) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_set_ptr.Value.Delegate(this.NativeHandle,l, r, t, b);
Eina.Error.RaiseIfUnhandledException();
}
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
public double GetBorderScale() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
public void SetBorderScale(double scale) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_set_ptr.Value.Delegate(this.NativeHandle,scale);
Eina.Error.RaiseIfUnhandledException();
}
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(this.NativeHandle,fill);
Eina.Error.RaiseIfUnhandledException();
}
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
/// Representation of area that are stretchable in the image vertical space.
public void GetStretchRegion(out Eina.Iterator horizontal, out Eina.Iterator vertical) {
System.IntPtr _out_horizontal = System.IntPtr.Zero;
System.IntPtr _out_vertical = System.IntPtr.Zero;
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_get_ptr.Value.Delegate(this.NativeHandle,out _out_horizontal, out _out_vertical);
Eina.Error.RaiseIfUnhandledException();
horizontal = new Eina.Iterator(_out_horizontal, false);
vertical = new Eina.Iterator(_out_vertical, false);
}
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
/// Representation of area that are stretchable in the image vertical space.
/// return an error code if the stretch_region provided are incorrect.
public Eina.Error SetStretchRegion(Eina.Iterator horizontal, Eina.Iterator vertical) {
var _in_horizontal = horizontal.Handle;
var _in_vertical = vertical.Handle;
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_set_ptr.Value.Delegate(this.NativeHandle,_in_horizontal, _in_vertical);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// This represents the size of the original image in pixels.
/// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
///
/// This is a read-only property, and may return 0x0.
/// The size in pixels.
public Eina.Size2D GetImageSize() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_size_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Get the content hint setting of a given image object of the canvas.
/// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
/// Dynamic or static content hint, see
public Efl.Gfx.ImageContentHint GetContentHint() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Set the content hint setting of a given image object of the canvas.
/// This function sets the content hint value of the given image of the canvas. For example, if you're on the GL engine and your driver implementation supports it, setting this hint to #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies at texture upload time, which is an "expensive" operation.
/// Dynamic or static content hint, see
public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_set_ptr.Value.Delegate(this.NativeHandle,hint);
Eina.Error.RaiseIfUnhandledException();
}
/// Get the scale hint of a given image of the canvas.
/// This function returns the scale hint value of the given image object of the canvas.
/// Scalable or static size hint, see
public Efl.Gfx.ImageScaleHint GetScaleHint() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Set the scale hint of a given image of the canvas.
/// This function sets the scale hint value of the given image object in the canvas, which will affect how Evas is to cache scaled versions of its original source image.
/// Scalable or static size hint, see
public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_set_ptr.Value.Delegate(this.NativeHandle,hint);
Eina.Error.RaiseIfUnhandledException();
}
/// Gets the (last) file loading error for a given object.
/// The load error code.
public Eina.Error GetImageLoadError() {
var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_load_error_get_ptr.Value.Delegate(this.NativeHandle);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// Whether to use high-quality image scaling algorithm for this image.
/// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image's original one. This gives better results but is more computationally expensive.
///
/// true by default
/// Whether to use smooth scale or not.
public bool SmoothScale {
get { return GetSmoothScale(); }
set { SetSmoothScale(value); }
}
/// Control how the image is scaled.
/// Image scale type
public Efl.Gfx.ImageScaleType ScaleType {
get { return GetScaleType(); }
set { SetScaleType(value); }
}
/// If true, the image may be scaled to a larger size. If false, the image will never be resized larger than its native size. This is set to true by default.
/// Allow image upscaling
public bool CanUpscale {
get { return GetCanUpscale(); }
set { SetCanUpscale(value); }
}
/// If true, the image may be scaled to a smaller size. If false, the image will never be resized smaller than its native size. This is set to true by default.
/// Allow image downscaling
public bool CanDownscale {
get { return GetCanDownscale(); }
set { SetCanDownscale(value); }
}
/// The native width/height ratio of the image.
/// The image's ratio.
public double Ratio {
get { return GetRatio(); }
}
/// Return the relative area enclosed inside the image where content is expected.
/// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
///
/// The geometry of the area is expressed relative to the geometry of the object.
/// A rectangle inside the object boundary that where content is expected.
public Eina.Rect ContentRegion {
get { return GetContentRegion(); }
}
/// Dimensions of this image's border, a region that does not scale with the center area.
/// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
///
/// The units used for l, r, t and b are canvas units (pixels).
///
/// Note: The border region itself may be scaled by the function.
///
/// Note: By default, image objects have no borders set, i.e. l, r, t and b start as 0.
///
/// Note: Similar to the concepts of 9-patch images or cap insets.
/// The border's left width.
public (int, int, int, int) Border {
get {
int _out_l = default(int);
int _out_r = default(int);
int _out_t = default(int);
int _out_b = default(int);
GetBorder(out _out_l,out _out_r,out _out_t,out _out_b);
return (_out_l,_out_r,_out_t,_out_b);
}
set { SetBorder( value.Item1, value.Item2, value.Item3, value.Item4); }
}
/// Scaling factor applied to the image borders.
/// This value multiplies the size of the when scaling an object.
///
/// Default value is 1.0 (no scaling).
/// The scale factor.
public double BorderScale {
get { return GetBorderScale(); }
set { SetBorderScale(value); }
}
/// Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
/// This function sets how the center part of the image object's source image is to be drawn, which must be one of the values in . By center we mean the complementary part of that defined by . This is very useful for making frames and decorations. You would most probably also be using a filled image (as in ) to use as a frame.
///
/// The default value is , ie. render and scale the center area, respecting its transparency.
/// Fill mode of the center region.
public Efl.Gfx.BorderFillMode BorderCenterFill {
get { return GetBorderCenterFill(); }
set { SetBorderCenterFill(value); }
}
/// This property defines the stretchable pixels region of an image.
/// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of , and . To reset the object you can just pass null to both horizontal and vertical at the same time.
/// Representation of area that are stretchable in the image horizontal space.
public (Eina.Iterator, Eina.Iterator) StretchRegion {
get {
Eina.Iterator _out_horizontal = default(Eina.Iterator);
Eina.Iterator _out_vertical = default(Eina.Iterator);
GetStretchRegion(out _out_horizontal,out _out_vertical);
return (_out_horizontal,_out_vertical);
}
set { SetStretchRegion( value.Item1, value.Item2); }
}
/// This represents the size of the original image in pixels.
/// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
///
/// This is a read-only property, and may return 0x0.
/// The size in pixels.
public Eina.Size2D ImageSize {
get { return GetImageSize(); }
}
/// Get the content hint setting of a given image object of the canvas.
/// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
/// Dynamic or static content hint, see
public Efl.Gfx.ImageContentHint ContentHint {
get { return GetContentHint(); }
set { SetContentHint(value); }
}
/// Get the scale hint of a given image of the canvas.
/// This function returns the scale hint value of the given image object of the canvas.
/// Scalable or static size hint, see
public Efl.Gfx.ImageScaleHint ScaleHint {
get { return GetScaleHint(); }
set { SetScaleHint(value); }
}
/// Gets the (last) file loading error for a given object.
/// The load error code.
public Eina.Error ImageLoadError {
get { return GetImageLoadError(); }
}
private static IntPtr GetEflClassStatic()
{
return Efl.Gfx.IImageConcrete.efl_gfx_image_interface_get();
}
/// Wrapper for native methods and virtual method delegates.
/// For internal use by generated code only.
public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
{
private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
/// Gets the list of Eo operations to override.
/// The list of Eo operations to be overload.
public override System.Collections.Generic.List GetEoOps(System.Type type)
{
var descs = new System.Collections.Generic.List();
var methods = Efl.Eo.Globals.GetUserMethods(type);
if (efl_gfx_image_smooth_scale_get_static_delegate == null)
{
efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_get_static_delegate) });
}
if (efl_gfx_image_smooth_scale_set_static_delegate == null)
{
efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_set_static_delegate) });
}
if (efl_gfx_image_scale_type_get_static_delegate == null)
{
efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_get_static_delegate) });
}
if (efl_gfx_image_scale_type_set_static_delegate == null)
{
efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_set_static_delegate) });
}
if (efl_gfx_image_can_upscale_get_static_delegate == null)
{
efl_gfx_image_can_upscale_get_static_delegate = new efl_gfx_image_can_upscale_get_delegate(can_upscale_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetCanUpscale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_upscale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_upscale_get_static_delegate) });
}
if (efl_gfx_image_can_upscale_set_static_delegate == null)
{
efl_gfx_image_can_upscale_set_static_delegate = new efl_gfx_image_can_upscale_set_delegate(can_upscale_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetCanUpscale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_upscale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_upscale_set_static_delegate) });
}
if (efl_gfx_image_can_downscale_get_static_delegate == null)
{
efl_gfx_image_can_downscale_get_static_delegate = new efl_gfx_image_can_downscale_get_delegate(can_downscale_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetCanDownscale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_downscale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_downscale_get_static_delegate) });
}
if (efl_gfx_image_can_downscale_set_static_delegate == null)
{
efl_gfx_image_can_downscale_set_static_delegate = new efl_gfx_image_can_downscale_set_delegate(can_downscale_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetCanDownscale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_downscale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_downscale_set_static_delegate) });
}
if (efl_gfx_image_ratio_get_static_delegate == null)
{
efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_ratio_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_ratio_get_static_delegate) });
}
if (efl_gfx_image_content_region_get_static_delegate == null)
{
efl_gfx_image_content_region_get_static_delegate = new efl_gfx_image_content_region_get_delegate(content_region_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetContentRegion") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_region_get_static_delegate) });
}
if (efl_gfx_image_border_get_static_delegate == null)
{
efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_get_static_delegate) });
}
if (efl_gfx_image_border_set_static_delegate == null)
{
efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_set_static_delegate) });
}
if (efl_gfx_image_border_scale_get_static_delegate == null)
{
efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_get_static_delegate) });
}
if (efl_gfx_image_border_scale_set_static_delegate == null)
{
efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_set_static_delegate) });
}
if (efl_gfx_image_border_center_fill_get_static_delegate == null)
{
efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_get_static_delegate) });
}
if (efl_gfx_image_border_center_fill_set_static_delegate == null)
{
efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_set_static_delegate) });
}
if (efl_gfx_image_stretch_region_get_static_delegate == null)
{
efl_gfx_image_stretch_region_get_static_delegate = new efl_gfx_image_stretch_region_get_delegate(stretch_region_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetStretchRegion") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_get_static_delegate) });
}
if (efl_gfx_image_stretch_region_set_static_delegate == null)
{
efl_gfx_image_stretch_region_set_static_delegate = new efl_gfx_image_stretch_region_set_delegate(stretch_region_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetStretchRegion") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_set_static_delegate) });
}
if (efl_gfx_image_size_get_static_delegate == null)
{
efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_size_get_static_delegate) });
}
if (efl_gfx_image_content_hint_get_static_delegate == null)
{
efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_get_static_delegate) });
}
if (efl_gfx_image_content_hint_set_static_delegate == null)
{
efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_set_static_delegate) });
}
if (efl_gfx_image_scale_hint_get_static_delegate == null)
{
efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_get_static_delegate) });
}
if (efl_gfx_image_scale_hint_set_static_delegate == null)
{
efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
}
if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_set_static_delegate) });
}
if (efl_gfx_image_load_error_get_static_delegate == null)
{
efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
}
if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
{
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_error_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_error_get_static_delegate) });
}
return descs;
}
/// Returns the Eo class for the native methods of this class.
/// The native class pointer.
public override IntPtr GetEflClass()
{
return Efl.Gfx.IImageConcrete.efl_gfx_image_interface_get();
}
#pragma warning disable CA1707, CS1591, SA1300, SA1600
[return: MarshalAs(UnmanagedType.U1)]
private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
[return: MarshalAs(UnmanagedType.U1)]
public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_smooth_scale_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_smooth_scale_get");
private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
bool _ret_var = default(bool);
try
{
_ret_var = ((IImage)ws.Target).GetSmoothScale();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
public static Efl.Eo.FunctionWrapper efl_gfx_image_smooth_scale_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_smooth_scale_set");
private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
{
Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetSmoothScale(smooth_scale);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
}
}
private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_scale_type_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_scale_type_get");
private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
try
{
_ret_var = ((IImage)ws.Target).GetScaleType();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type);
public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj, Efl.Gfx.ImageScaleType scale_type);
public static Efl.Eo.FunctionWrapper efl_gfx_image_scale_type_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_scale_type_set");
private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
{
Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetScaleType(scale_type);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
}
}
private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
[return: MarshalAs(UnmanagedType.U1)]
private delegate bool efl_gfx_image_can_upscale_get_delegate(System.IntPtr obj, System.IntPtr pd);
[return: MarshalAs(UnmanagedType.U1)]
public delegate bool efl_gfx_image_can_upscale_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_can_upscale_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_can_upscale_get");
private static bool can_upscale_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_can_upscale_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
bool _ret_var = default(bool);
try
{
_ret_var = ((IImage)ws.Target).GetCanUpscale();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_can_upscale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_can_upscale_get_delegate efl_gfx_image_can_upscale_get_static_delegate;
private delegate void efl_gfx_image_can_upscale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool upscale);
public delegate void efl_gfx_image_can_upscale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool upscale);
public static Efl.Eo.FunctionWrapper efl_gfx_image_can_upscale_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_can_upscale_set");
private static void can_upscale_set(System.IntPtr obj, System.IntPtr pd, bool upscale)
{
Eina.Log.Debug("function efl_gfx_image_can_upscale_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetCanUpscale(upscale);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_can_upscale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), upscale);
}
}
private static efl_gfx_image_can_upscale_set_delegate efl_gfx_image_can_upscale_set_static_delegate;
[return: MarshalAs(UnmanagedType.U1)]
private delegate bool efl_gfx_image_can_downscale_get_delegate(System.IntPtr obj, System.IntPtr pd);
[return: MarshalAs(UnmanagedType.U1)]
public delegate bool efl_gfx_image_can_downscale_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_can_downscale_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_can_downscale_get");
private static bool can_downscale_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_can_downscale_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
bool _ret_var = default(bool);
try
{
_ret_var = ((IImage)ws.Target).GetCanDownscale();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_can_downscale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_can_downscale_get_delegate efl_gfx_image_can_downscale_get_static_delegate;
private delegate void efl_gfx_image_can_downscale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool downscale);
public delegate void efl_gfx_image_can_downscale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool downscale);
public static Efl.Eo.FunctionWrapper efl_gfx_image_can_downscale_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_can_downscale_set");
private static void can_downscale_set(System.IntPtr obj, System.IntPtr pd, bool downscale)
{
Eina.Log.Debug("function efl_gfx_image_can_downscale_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetCanDownscale(downscale);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_can_downscale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), downscale);
}
}
private static efl_gfx_image_can_downscale_set_delegate efl_gfx_image_can_downscale_set_static_delegate;
private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_ratio_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_ratio_get");
private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
double _ret_var = default(double);
try
{
_ret_var = ((IImage)ws.Target).GetRatio();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
private delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_content_region_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_content_region_get");
private static Eina.Rect.NativeStruct content_region_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_content_region_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Eina.Rect _ret_var = default(Eina.Rect);
try
{
_ret_var = ((IImage)ws.Target).GetContentRegion();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_content_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_content_region_get_delegate efl_gfx_image_content_region_get_static_delegate;
private delegate void efl_gfx_image_border_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_image_border_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_image_border_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_get");
private static void border_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_image_border_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
l = default(int); r = default(int); t = default(int); b = default(int);
try
{
((IImage)ws.Target).GetBorder(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_image_border_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_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b);
public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj, int l, int r, int t, int b);
public static Efl.Eo.FunctionWrapper efl_gfx_image_border_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_set");
private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
{
Eina.Log.Debug("function efl_gfx_image_border_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetBorder(l, r, t, b);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_border_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_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_border_scale_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_scale_get");
private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
double _ret_var = default(double);
try
{
_ret_var = ((IImage)ws.Target).GetBorderScale();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, double scale);
public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj, double scale);
public static Efl.Eo.FunctionWrapper efl_gfx_image_border_scale_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_scale_set");
private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
{
Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetBorderScale(scale);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
}
}
private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_border_center_fill_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_center_fill_get");
private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
try
{
_ret_var = ((IImage)ws.Target).GetBorderCenterFill();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill);
public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj, Efl.Gfx.BorderFillMode fill);
public static Efl.Eo.FunctionWrapper efl_gfx_image_border_center_fill_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_border_center_fill_set");
private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
{
Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetBorderCenterFill(fill);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
}
}
private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
private delegate void efl_gfx_image_stretch_region_get_delegate(System.IntPtr obj, System.IntPtr pd, out System.IntPtr horizontal, out System.IntPtr vertical);
public delegate void efl_gfx_image_stretch_region_get_api_delegate(System.IntPtr obj, out System.IntPtr horizontal, out System.IntPtr vertical);
public static Efl.Eo.FunctionWrapper efl_gfx_image_stretch_region_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_stretch_region_get");
private static void stretch_region_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr horizontal, out System.IntPtr vertical)
{
Eina.Log.Debug("function efl_gfx_image_stretch_region_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Eina.Iterator _out_horizontal = default(Eina.Iterator);
Eina.Iterator _out_vertical = default(Eina.Iterator);
try
{
((IImage)ws.Target).GetStretchRegion(out _out_horizontal, out _out_vertical);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
horizontal = _out_horizontal.Handle;
vertical = _out_vertical.Handle;
}
else
{
efl_gfx_image_stretch_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out horizontal, out vertical);
}
}
private static efl_gfx_image_stretch_region_get_delegate efl_gfx_image_stretch_region_get_static_delegate;
private delegate Eina.Error efl_gfx_image_stretch_region_set_delegate(System.IntPtr obj, System.IntPtr pd, System.IntPtr horizontal, System.IntPtr vertical);
public delegate Eina.Error efl_gfx_image_stretch_region_set_api_delegate(System.IntPtr obj, System.IntPtr horizontal, System.IntPtr vertical);
public static Efl.Eo.FunctionWrapper efl_gfx_image_stretch_region_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_stretch_region_set");
private static Eina.Error stretch_region_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr horizontal, System.IntPtr vertical)
{
Eina.Log.Debug("function efl_gfx_image_stretch_region_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
var _in_horizontal = new Eina.Iterator(horizontal, false);
var _in_vertical = new Eina.Iterator(vertical, false);
Eina.Error _ret_var = default(Eina.Error);
try
{
_ret_var = ((IImage)ws.Target).SetStretchRegion(_in_horizontal, _in_vertical);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_stretch_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horizontal, vertical);
}
}
private static efl_gfx_image_stretch_region_set_delegate efl_gfx_image_stretch_region_set_static_delegate;
private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_size_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_size_get");
private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_size_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Eina.Size2D _ret_var = default(Eina.Size2D);
try
{
_ret_var = ((IImage)ws.Target).GetImageSize();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_content_hint_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_content_hint_get");
private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
try
{
_ret_var = ((IImage)ws.Target).GetContentHint();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint);
public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj, Efl.Gfx.ImageContentHint hint);
public static Efl.Eo.FunctionWrapper efl_gfx_image_content_hint_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_content_hint_set");
private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
{
Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetContentHint(hint);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
}
}
private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_scale_hint_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_scale_hint_get");
private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
try
{
_ret_var = ((IImage)ws.Target).GetScaleHint();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint);
public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj, Efl.Gfx.ImageScaleHint hint);
public static Efl.Eo.FunctionWrapper efl_gfx_image_scale_hint_set_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_scale_hint_set");
private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
{
Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
((IImage)ws.Target).SetScaleHint(hint);
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
}
else
{
efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
}
}
private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
public static Efl.Eo.FunctionWrapper efl_gfx_image_load_error_get_ptr = new Efl.Eo.FunctionWrapper(Module, "efl_gfx_image_load_error_get");
private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
{
Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
Eina.Error _ret_var = default(Eina.Error);
try
{
_ret_var = ((IImage)ws.Target).GetImageLoadError();
}
catch (Exception e)
{
Eina.Log.Warning($"Callback error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
return _ret_var;
}
else
{
return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
}
}
}
}
#if EFL_BETA
#pragma warning disable CS1591
public static class Efl_GfxIImageConcrete_ExtensionMethods {
public static Efl.BindableProperty SmoothScale(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("smooth_scale", fac);
}
public static Efl.BindableProperty ScaleType(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("scale_type", fac);
}
public static Efl.BindableProperty CanUpscale(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("can_upscale", fac);
}
public static Efl.BindableProperty CanDownscale(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("can_downscale", fac);
}
public static Efl.BindableProperty BorderScale(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("border_scale", fac);
}
public static Efl.BindableProperty BorderCenterFill(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("border_center_fill", fac);
}
public static Efl.BindableProperty ContentHint(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("content_hint", fac);
}
public static Efl.BindableProperty ScaleHint(this Efl.Ui.ItemFactory fac, Efl.Csharp.ExtensionTagmagic = null) where T : Efl.Gfx.IImage {
return new Efl.BindableProperty("scale_hint", fac);
}
}
#pragma warning restore CS1591
#endif
namespace Efl {
namespace Gfx {
/// How an image's data is to be treated by EFL, for optimization.
[Efl.Eo.BindingEntity]
public enum ImageContentHint
{
/// No hint on the content (default).
None = 0,
/// The content will change over time.
Dynamic = 1,
/// The content won't change over time.
Static = 2,
}
}
}
namespace Efl {
namespace Gfx {
/// How an image's data is to be treated by EFL, with regard to scaling cache.
[Efl.Eo.BindingEntity]
public enum ImageScaleHint
{
/// No hint on the scaling (default).
None = 0,
/// Image will be re-scaled over time, thus turning scaling cache OFF for its data.
Dynamic = 1,
/// Image will not be re-scaled over time, thus turning scaling cache ON for its data.
Static = 2,
}
}
}
namespace Efl {
namespace Gfx {
/// Enumeration that defines scale types of an image.
[Efl.Eo.BindingEntity]
public enum ImageScaleType
{
/// Use the image's natural size.
None = 0,
/// Scale the image so that it matches the object's area exactly. The image's aspect ratio might be changed.
Fill = 1,
/// Scale the image so that it fits completely inside the object's area while maintaining the aspect ratio. At least one of the dimensions of the image will be equal to the corresponding dimension of the object.
Fit = 2,
/// Scale the image so that it covers the entire object area horizontally while maintaining the aspect ratio. The image may become taller than the object.
FitWidth = 3,
/// Scale the image so that it covers the entire object area vertically while maintaining the aspect ratio. The image may become wider than the object.
FitHeight = 4,
/// Scale the image so that it covers the entire object area on one axis while maintaining the aspect ratio, preferring whichever axis is largest. The image may become larger than the object.
Expand = 5,
/// Tile image at its original size.
Tile = 6,
}
}
}
namespace Efl {
namespace Gfx {
/// This struct holds the description of a stretchable region in one dimension (vertical or horizontal). Used when scaling an image.
/// offset + length should be smaller than image size in that dimension.
[StructLayout(LayoutKind.Sequential)]
[Efl.Eo.BindingEntity]
public struct ImageStretchRegion
{
/// First pixel of the stretchable region, starting at 0.
public uint Offset;
/// Length of the stretchable region in pixels.
public uint Length;
/// Constructor for ImageStretchRegion.
/// First pixel of the stretchable region, starting at 0.;
/// Length of the stretchable region in pixels.;
public ImageStretchRegion(
uint Offset = default(uint),
uint Length = default(uint) )
{
this.Offset = Offset;
this.Length = Length;
}
/// Implicit conversion to the managed representation from a native pointer.
/// Native pointer to be converted.
public static implicit operator ImageStretchRegion(IntPtr ptr)
{
var tmp = (ImageStretchRegion.NativeStruct)Marshal.PtrToStructure(ptr, typeof(ImageStretchRegion.NativeStruct));
return tmp;
}
#pragma warning disable CS1591
/// Internal wrapper for struct ImageStretchRegion.
[StructLayout(LayoutKind.Sequential)]
public struct NativeStruct
{
public uint Offset;
public uint Length;
/// Implicit conversion to the internal/marshalling representation.
public static implicit operator ImageStretchRegion.NativeStruct(ImageStretchRegion _external_struct)
{
var _internal_struct = new ImageStretchRegion.NativeStruct();
_internal_struct.Offset = _external_struct.Offset;
_internal_struct.Length = _external_struct.Length;
return _internal_struct;
}
/// Implicit conversion to the managed representation.
public static implicit operator ImageStretchRegion(ImageStretchRegion.NativeStruct _internal_struct)
{
var _external_struct = new ImageStretchRegion();
_external_struct.Offset = _internal_struct.Offset;
_external_struct.Length = _internal_struct.Length;
return _external_struct;
}
}
#pragma warning restore CS1591
}
}
}