+#define EFL_BETA
#pragma warning disable CS1591
using System;
using System.Runtime.InteropServices;
namespace Ui {
/// <summary>Elementary widget internal part background class</summary>
+/// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
[Efl.Ui.WidgetPartBg.NativeMethods]
[Efl.Eo.BindingEntity]
public class WidgetPartBg : Efl.Ui.WidgetPart, Efl.IFile, Efl.Gfx.IColor, Efl.Gfx.IImage
{
- ///<summary>Pointer to the native class description.</summary>
+ /// <summary>Pointer to the native class description.</summary>
public override System.IntPtr NativeClass
{
get
FinishInstantiation();
}
- /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
+ /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
+ /// Do not call this constructor directly.</summary>
/// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
protected WidgetPartBg(ConstructingHandle ch) : base(ch)
{
}
}
}
- ///<summary>Method to raise event ImagePreloadEvt.</summary>
+ /// <summary>Method to raise event ImagePreloadEvt.</summary>
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
}
}
}
- ///<summary>Method to raise event ImageResizeEvt.</summary>
+ /// <summary>Method to raise event ImageResizeEvt.</summary>
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
}
}
}
- ///<summary>Method to raise event ImageUnloadEvt.</summary>
+ /// <summary>Method to raise event ImageUnloadEvt.</summary>
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale_type);
Eina.Error.RaiseIfUnhandledException();
}
+ /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
+ /// <returns>Allow image upscaling</returns>
+ virtual public bool GetCanUpscale() {
+ var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
+ /// <param name="upscale">Allow image upscaling</param>
+ virtual public void SetCanUpscale(bool upscale) {
+ Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),upscale);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
+ /// <returns>Allow image downscaling</returns>
+ virtual public bool GetCanDownscale() {
+ var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
+ /// <param name="downscale">Allow image downscaling</param>
+ virtual public void SetCanDownscale(bool downscale) {
+ Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),downscale);
+ Eina.Error.RaiseIfUnhandledException();
+ }
/// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
/// <returns>The image's ratio.</returns>
virtual public double GetRatio() {
/// 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 <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
/// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
/// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
- virtual public void GetStretchRegion(out Eina.Iterator<Efl.Gfx.Image.StretchRegion> horizontal, out Eina.Iterator<Efl.Gfx.Image.StretchRegion> vertical) {
+ virtual public void GetStretchRegion(out Eina.Iterator<Efl.Gfx.ImageStretchRegion> horizontal, out Eina.Iterator<Efl.Gfx.ImageStretchRegion> 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((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out _out_horizontal, out _out_vertical);
Eina.Error.RaiseIfUnhandledException();
- horizontal = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(_out_horizontal, false);
- vertical = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(_out_vertical, false);
+ horizontal = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(_out_horizontal, false);
+ vertical = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(_out_vertical, false);
}
/// <summary>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 <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
/// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
/// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
/// <returns>return an error code if the stretch_region provided are incorrect.</returns>
- virtual public Eina.Error SetStretchRegion(Eina.Iterator<Efl.Gfx.Image.StretchRegion> horizontal, Eina.Iterator<Efl.Gfx.Image.StretchRegion> vertical) {
+ virtual public Eina.Error SetStretchRegion(Eina.Iterator<Efl.Gfx.ImageStretchRegion> horizontal, Eina.Iterator<Efl.Gfx.ImageStretchRegion> 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((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_horizontal, _in_vertical);
public bool Loaded {
get { return GetLoaded(); }
}
+ /// <summary>Retrieves the general/main color of the given Evas object.
+ /// Retrieves the main color's RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object's transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
+ ///
+ /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
+ ///
+ /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
+ ///
+ /// Use null pointers on the components you're not interested in: they'll be ignored by the function.
+ /// (Since EFL 1.22)</summary>
+ public (int, int, int, int) Color {
+ get {
+ int _out_r = default(int);
+ int _out_g = default(int);
+ int _out_b = default(int);
+ int _out_a = default(int);
+ GetColor(out _out_r,out _out_g,out _out_b,out _out_a);
+ return (_out_r,_out_g,_out_b,_out_a);
+ }
+ set { SetColor( value.Item1, value.Item2, value.Item3, value.Item4); }
+ }
/// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
/// (Since EFL 1.22)</summary>
/// <value>the hex color code.</value>
get { return GetScaleType(); }
set { SetScaleType(value); }
}
+ /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
+ /// <value>Allow image upscaling</value>
+ public bool CanUpscale {
+ get { return GetCanUpscale(); }
+ set { SetCanUpscale(value); }
+ }
+ /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
+ /// <value>Allow image downscaling</value>
+ public bool CanDownscale {
+ get { return GetCanDownscale(); }
+ set { SetCanDownscale(value); }
+ }
/// <summary>The native width/height ratio of the image.</summary>
/// <value>The image's ratio.</value>
public double Ratio {
public Eina.Rect ContentRegion {
get { return GetContentRegion(); }
}
+ /// <summary>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 <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
+ ///
+ /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
+ ///
+ /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
+ ///
+ /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
+ /// <value>The border's left width.</value>
+ 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); }
+ }
/// <summary>Scaling factor applied to the image borders.
/// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
///
get { return GetBorderCenterFill(); }
set { SetBorderCenterFill(value); }
}
+ /// <summary>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 <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
+ /// <value>Representation of area that are stretchable in the image horizontal space.</value>
+ public (Eina.Iterator<Efl.Gfx.ImageStretchRegion>, Eina.Iterator<Efl.Gfx.ImageStretchRegion>) StretchRegion {
+ get {
+ Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
+ Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
+ GetStretchRegion(out _out_horizontal,out _out_vertical);
+ return (_out_horizontal,_out_vertical);
+ }
+ set { SetStretchRegion( value.Item1, value.Item2); }
+ }
/// <summary>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.
///
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);
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_api_delegate> efl_gfx_image_can_upscale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_get_api_delegate>(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 = ((WidgetPartBg)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_api_delegate> efl_gfx_image_can_upscale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_set_api_delegate>(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
+ {
+ ((WidgetPartBg)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_api_delegate> efl_gfx_image_can_downscale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_get_api_delegate>(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 = ((WidgetPartBg)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_api_delegate> efl_gfx_image_can_downscale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_set_api_delegate>(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
+ {
+ ((WidgetPartBg)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);
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- Eina.Iterator<Efl.Gfx.Image.StretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.Image.StretchRegion>);
- Eina.Iterator<Efl.Gfx.Image.StretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.Image.StretchRegion>);
+ Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
+ Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
try
{
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- var _in_horizontal = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(horizontal, false);
- var _in_vertical = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(vertical, false);
+ var _in_horizontal = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(horizontal, false);
+ var _in_vertical = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(vertical, false);
Eina.Error _ret_var = default(Eina.Error);
try
{
}
+#if EFL_BETA
+#pragma warning disable CS1591
+public static class Efl_UiWidgetPartBg_ExtensionMethods {
+ public static Efl.BindableProperty<Eina.File> Mmap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<Eina.File>("mmap", fac);
+ }
+
+ public static Efl.BindableProperty<System.String> File<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<System.String>("file", fac);
+ }
+
+ public static Efl.BindableProperty<System.String> Key<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<System.String>("key", fac);
+ }
+
+
+
+ public static Efl.BindableProperty<System.String> ColorCode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<System.String>("color_code", fac);
+ }
+
+ public static Efl.BindableProperty<bool> SmoothScale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<bool>("smooth_scale", fac);
+ }
+
+ public static Efl.BindableProperty<Efl.Gfx.ImageScaleType> ScaleType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<Efl.Gfx.ImageScaleType>("scale_type", fac);
+ }
+
+ public static Efl.BindableProperty<bool> CanUpscale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<bool>("can_upscale", fac);
+ }
+
+ public static Efl.BindableProperty<bool> CanDownscale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<bool>("can_downscale", fac);
+ }
+
+
+
+
+ public static Efl.BindableProperty<double> BorderScale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<double>("border_scale", fac);
+ }
+
+ public static Efl.BindableProperty<Efl.Gfx.BorderFillMode> BorderCenterFill<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<Efl.Gfx.BorderFillMode>("border_center_fill", fac);
+ }
+
+
+
+ public static Efl.BindableProperty<Efl.Gfx.ImageContentHint> ContentHint<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<Efl.Gfx.ImageContentHint>("content_hint", fac);
+ }
+
+ public static Efl.BindableProperty<Efl.Gfx.ImageScaleHint> ScaleHint<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
+ return new Efl.BindableProperty<Efl.Gfx.ImageScaleHint>("scale_hint", fac);
+ }
+
+
+}
+#pragma warning restore CS1591
+#endif
projects / platform / core / csapi / tizenfx.git / blobdiff