internals/src/EflSharp/EflSharp/efl/efl_canvas_layout_part.eo.cs

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Canvas {
  12
  13 /// <summary>Common class for part proxy objects for <see cref="Efl.Canvas.Layout"/>.
  14 /// As an <see cref="Efl.IPart"/> implementation class, all objects of this class are meant to be used for one and only one function call. In pseudo-code, the use of object of this type looks like the following: rect = layout.part(&quot;somepart&quot;).geometry_get();</summary>
  15 /// <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>
  16 [Efl.Canvas.LayoutPart.NativeMethods]
  17 [Efl.Eo.BindingEntity]
  18 public class LayoutPart : Efl.Object, Efl.Gfx.IEntity, Efl.Ui.IDrag
  19 {
  20     /// <summary>Pointer to the native class description.</summary>
  21     public override System.IntPtr NativeClass
  22     {
  23         get
  24         {
  25             if (((object)this).GetType() == typeof(LayoutPart))
  26             {
  27                 return GetEflClassStatic();
  28             }
  29             else
  30             {
  31                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  32             }
  33         }
  34     }
  35
  36     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  37         efl_canvas_layout_part_class_get();
  38     /// <summary>Initializes a new instance of the <see cref="LayoutPart"/> class.</summary>
  39     /// <param name="parent">Parent instance.</param>
  40     public LayoutPart(Efl.Object parent= null
  41             ) : base(efl_canvas_layout_part_class_get(), parent)
  42     {
  43         FinishInstantiation();
  44     }
  45
  46     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  47     /// Do not call this constructor directly.</summary>
  48     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  49     protected LayoutPart(ConstructingHandle ch) : base(ch)
  50     {
  51     }
  52
  53     /// <summary>Initializes a new instance of the <see cref="LayoutPart"/> class.
  54     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  55     /// <param name="wh">The native pointer to be wrapped.</param>
  56     protected LayoutPart(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  57     {
  58     }
  59
  60     /// <summary>Initializes a new instance of the <see cref="LayoutPart"/> class.
  61     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  62     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  63     /// <param name="parent">The Efl.Object parent of this instance.</param>
  64     protected LayoutPart(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  65     {
  66     }
  67
  68     /// <summary>Object&apos;s visibility state changed, the event value is the new state.
  69     /// (Since EFL 1.22)</summary>
  70     /// <value><see cref="Efl.Gfx.IEntityVisibilityChangedEvt_Args"/></value>
  71     public event EventHandler<Efl.Gfx.IEntityVisibilityChangedEvt_Args> VisibilityChangedEvt
  72     {
  73         add
  74         {
  75             lock (eflBindingEventLock)
  76             {
  77                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  78                 {
  79                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  80                     if (obj != null)
  81                     {
  82                         Efl.Gfx.IEntityVisibilityChangedEvt_Args args = new Efl.Gfx.IEntityVisibilityChangedEvt_Args();
  83                         args.arg = Marshal.ReadByte(evt.Info) != 0;
  84                         try
  85                         {
  86                             value?.Invoke(obj, args);
  87                         }
  88                         catch (Exception e)
  89                         {
  90                             Eina.Log.Error(e.ToString());
  91                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  92                         }
  93                     }
  94                 };
  95
  96                 string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
  97                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
  98             }
  99         }
 100
 101         remove
 102         {
 103             lock (eflBindingEventLock)
 104             {
 105                 string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
 106                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 107             }
 108         }
 109     }
 110     /// <summary>Method to raise event VisibilityChangedEvt.</summary>
 111     public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
 112     {
 113         var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
 114         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 115         if (desc == IntPtr.Zero)
 116         {
 117             Eina.Log.Error($"Failed to get native event {key}");
 118             return;
 119         }
 120
 121         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 122         try
 123         {
 124             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 125         }
 126         finally
 127         {
 128             Marshal.FreeHGlobal(info);
 129         }
 130     }
 131     /// <summary>Object was moved, its position during the event is the new one.
 132     /// (Since EFL 1.22)</summary>
 133     /// <value><see cref="Efl.Gfx.IEntityPositionChangedEvt_Args"/></value>
 134     public event EventHandler<Efl.Gfx.IEntityPositionChangedEvt_Args> PositionChangedEvt
 135     {
 136         add
 137         {
 138             lock (eflBindingEventLock)
 139             {
 140                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 141                 {
 142                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 143                     if (obj != null)
 144                     {
 145                         Efl.Gfx.IEntityPositionChangedEvt_Args args = new Efl.Gfx.IEntityPositionChangedEvt_Args();
 146                         args.arg =  evt.Info;
 147                         try
 148                         {
 149                             value?.Invoke(obj, args);
 150                         }
 151                         catch (Exception e)
 152                         {
 153                             Eina.Log.Error(e.ToString());
 154                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 155                         }
 156                     }
 157                 };
 158
 159                 string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 160                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
 161             }
 162         }
 163
 164         remove
 165         {
 166             lock (eflBindingEventLock)
 167             {
 168                 string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 169                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 170             }
 171         }
 172     }
 173     /// <summary>Method to raise event PositionChangedEvt.</summary>
 174     public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
 175     {
 176         var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 177         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 178         if (desc == IntPtr.Zero)
 179         {
 180             Eina.Log.Error($"Failed to get native event {key}");
 181             return;
 182         }
 183
 184         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 185         try
 186         {
 187             Marshal.StructureToPtr(e.arg, info, false);
 188             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 189         }
 190         finally
 191         {
 192             Marshal.FreeHGlobal(info);
 193         }
 194     }
 195     /// <summary>Object was resized, its size during the event is the new one.
 196     /// (Since EFL 1.22)</summary>
 197     /// <value><see cref="Efl.Gfx.IEntitySizeChangedEvt_Args"/></value>
 198     public event EventHandler<Efl.Gfx.IEntitySizeChangedEvt_Args> SizeChangedEvt
 199     {
 200         add
 201         {
 202             lock (eflBindingEventLock)
 203             {
 204                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 205                 {
 206                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 207                     if (obj != null)
 208                     {
 209                         Efl.Gfx.IEntitySizeChangedEvt_Args args = new Efl.Gfx.IEntitySizeChangedEvt_Args();
 210                         args.arg =  evt.Info;
 211                         try
 212                         {
 213                             value?.Invoke(obj, args);
 214                         }
 215                         catch (Exception e)
 216                         {
 217                             Eina.Log.Error(e.ToString());
 218                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 219                         }
 220                     }
 221                 };
 222
 223                 string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 224                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
 225             }
 226         }
 227
 228         remove
 229         {
 230             lock (eflBindingEventLock)
 231             {
 232                 string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 233                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 234             }
 235         }
 236     }
 237     /// <summary>Method to raise event SizeChangedEvt.</summary>
 238     public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
 239     {
 240         var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 241         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 242         if (desc == IntPtr.Zero)
 243         {
 244             Eina.Log.Error($"Failed to get native event {key}");
 245             return;
 246         }
 247
 248         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 249         try
 250         {
 251             Marshal.StructureToPtr(e.arg, info, false);
 252             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 253         }
 254         finally
 255         {
 256             Marshal.FreeHGlobal(info);
 257         }
 258     }
 259     /// <summary>The name and value of the current state of this part (read-only).
 260     /// This is the state name as it appears in EDC description blocks. A state has both a name and a value (double). The default state is &quot;default&quot; 0.0, but this function will return &quot;&quot; if the part is invalid.</summary>
 261     /// <param name="state">The name of the state.</param>
 262     /// <param name="val">The value of the state.</param>
 263     virtual public void GetState(out System.String state, out double val) {
 264                                                          Efl.Canvas.LayoutPart.NativeMethods.efl_canvas_layout_part_state_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out state, out val);
 265         Eina.Error.RaiseIfUnhandledException();
 266                                          }
 267     /// <summary>Returns the type of the part.</summary>
 268     /// <returns>One of the types or <c>none</c> if not an existing part.</returns>
 269     virtual public Efl.Canvas.LayoutPartType GetPartType() {
 270          var _ret_var = Efl.Canvas.LayoutPart.NativeMethods.efl_canvas_layout_part_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 271         Eina.Error.RaiseIfUnhandledException();
 272         return _ret_var;
 273  }
 274     /// <summary>Retrieves the position of the given canvas object.
 275     /// (Since EFL 1.22)</summary>
 276     /// <returns>A 2D coordinate in pixel units.</returns>
 277     virtual public Eina.Position2D GetPosition() {
 278          var _ret_var = Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_position_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 279         Eina.Error.RaiseIfUnhandledException();
 280         return _ret_var;
 281  }
 282     /// <summary>Moves the given canvas object to the given location inside its canvas&apos; viewport. If unchanged this call may be entirely skipped, but if changed this will trigger move events, as well as potential pointer,in or pointer,out events.
 283     /// (Since EFL 1.22)</summary>
 284     /// <param name="pos">A 2D coordinate in pixel units.</param>
 285     virtual public void SetPosition(Eina.Position2D pos) {
 286          Eina.Position2D.NativeStruct _in_pos = pos;
 287                         Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_position_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_pos);
 288         Eina.Error.RaiseIfUnhandledException();
 289                          }
 290     /// <summary>Retrieves the (rectangular) size of the given Evas object.
 291     /// (Since EFL 1.22)</summary>
 292     /// <returns>A 2D size in pixel units.</returns>
 293     virtual public Eina.Size2D GetSize() {
 294          var _ret_var = Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 295         Eina.Error.RaiseIfUnhandledException();
 296         return _ret_var;
 297  }
 298     /// <summary>Changes the size of the given object.
 299     /// Note that setting the actual size of an object might be the job of its container, so this function might have no effect. Look at <see cref="Efl.Gfx.IHint"/> instead, when manipulating widgets.
 300     /// (Since EFL 1.22)</summary>
 301     /// <param name="size">A 2D size in pixel units.</param>
 302     virtual public void SetSize(Eina.Size2D size) {
 303          Eina.Size2D.NativeStruct _in_size = size;
 304                         Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_size);
 305         Eina.Error.RaiseIfUnhandledException();
 306                          }
 307     /// <summary>Rectangular geometry that combines both position and size.
 308     /// (Since EFL 1.22)</summary>
 309     /// <returns>The X,Y position and W,H size, in pixels.</returns>
 310     virtual public Eina.Rect GetGeometry() {
 311          var _ret_var = Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_geometry_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 312         Eina.Error.RaiseIfUnhandledException();
 313         return _ret_var;
 314  }
 315     /// <summary>Rectangular geometry that combines both position and size.
 316     /// (Since EFL 1.22)</summary>
 317     /// <param name="rect">The X,Y position and W,H size, in pixels.</param>
 318     virtual public void SetGeometry(Eina.Rect rect) {
 319          Eina.Rect.NativeStruct _in_rect = rect;
 320                         Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_geometry_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_rect);
 321         Eina.Error.RaiseIfUnhandledException();
 322                          }
 323     /// <summary>Retrieves whether or not the given canvas object is visible.
 324     /// (Since EFL 1.22)</summary>
 325     /// <returns><c>true</c> if to make the object visible, <c>false</c> otherwise</returns>
 326     virtual public bool GetVisible() {
 327          var _ret_var = Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_visible_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 328         Eina.Error.RaiseIfUnhandledException();
 329         return _ret_var;
 330  }
 331     /// <summary>Shows or hides this object.
 332     /// (Since EFL 1.22)</summary>
 333     /// <param name="v"><c>true</c> if to make the object visible, <c>false</c> otherwise</param>
 334     virtual public void SetVisible(bool v) {
 335                                  Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_visible_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),v);
 336         Eina.Error.RaiseIfUnhandledException();
 337                          }
 338     /// <summary>Gets an object&apos;s scaling factor.
 339     /// (Since EFL 1.22)</summary>
 340     /// <returns>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</returns>
 341     virtual public double GetScale() {
 342          var _ret_var = Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_scale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 343         Eina.Error.RaiseIfUnhandledException();
 344         return _ret_var;
 345  }
 346     /// <summary>Sets the scaling factor of an object.
 347     /// (Since EFL 1.22)</summary>
 348     /// <param name="scale">The scaling factor (the default value is 0.0, meaning individual scaling is not set)</param>
 349     virtual public void SetScale(double scale) {
 350                                  Efl.Gfx.IEntityConcrete.NativeMethods.efl_gfx_entity_scale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale);
 351         Eina.Error.RaiseIfUnhandledException();
 352                          }
 353     /// <summary>Gets the draggable object location.</summary>
 354     /// <param name="dx">The x relative position, from 0 to 1.</param>
 355     /// <param name="dy">The y relative position, from 0 to 1.</param>
 356     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 357     virtual public bool GetDragValue(out double dx, out double dy) {
 358                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_value_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out dx, out dy);
 359         Eina.Error.RaiseIfUnhandledException();
 360                                         return _ret_var;
 361  }
 362     /// <summary>Sets the draggable object location.
 363     /// This places the draggable object at the given location.</summary>
 364     /// <param name="dx">The x relative position, from 0 to 1.</param>
 365     /// <param name="dy">The y relative position, from 0 to 1.</param>
 366     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 367     virtual public bool SetDragValue(double dx, double dy) {
 368                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_value_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dx, dy);
 369         Eina.Error.RaiseIfUnhandledException();
 370                                         return _ret_var;
 371  }
 372     /// <summary>Gets the size of the dradgable object.</summary>
 373     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 374     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 375     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 376     virtual public bool GetDragSize(out double dw, out double dh) {
 377                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out dw, out dh);
 378         Eina.Error.RaiseIfUnhandledException();
 379                                         return _ret_var;
 380  }
 381     /// <summary>Sets the size of the draggable object.</summary>
 382     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 383     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 384     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 385     virtual public bool SetDragSize(double dw, double dh) {
 386                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dw, dh);
 387         Eina.Error.RaiseIfUnhandledException();
 388                                         return _ret_var;
 389  }
 390     /// <summary>Gets the draggable direction.</summary>
 391     /// <returns>The direction(s) premitted for drag.</returns>
 392     virtual public Efl.Ui.DragDir GetDragDir() {
 393          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_dir_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 394         Eina.Error.RaiseIfUnhandledException();
 395         return _ret_var;
 396  }
 397     /// <summary>Gets the x and y step increments for the draggable object.</summary>
 398     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 399     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 400     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 401     virtual public bool GetDragStep(out double dx, out double dy) {
 402                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out dx, out dy);
 403         Eina.Error.RaiseIfUnhandledException();
 404                                         return _ret_var;
 405  }
 406     /// <summary>Sets the x,y step increments for a draggable object.</summary>
 407     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 408     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 409     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 410     virtual public bool SetDragStep(double dx, double dy) {
 411                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dx, dy);
 412         Eina.Error.RaiseIfUnhandledException();
 413                                         return _ret_var;
 414  }
 415     /// <summary>Gets the x,y page step increments for the draggable object.</summary>
 416     /// <param name="dx">The x page step increment</param>
 417     /// <param name="dy">The y page step increment</param>
 418     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 419     virtual public bool GetDragPage(out double dx, out double dy) {
 420                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out dx, out dy);
 421         Eina.Error.RaiseIfUnhandledException();
 422                                         return _ret_var;
 423  }
 424     /// <summary>Sets the x,y page step increment values.</summary>
 425     /// <param name="dx">The x page step increment</param>
 426     /// <param name="dy">The y page step increment</param>
 427     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 428     virtual public bool SetDragPage(double dx, double dy) {
 429                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dx, dy);
 430         Eina.Error.RaiseIfUnhandledException();
 431                                         return _ret_var;
 432  }
 433     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
 434     /// This moves the draggable part by <c>dx</c>,<c>dy</c> steps where the step increment is the amount set by <see cref="Efl.Ui.IDrag.GetDragStep"/>.
 435     ///
 436     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.</summary>
 437     /// <param name="dx">The number of steps horizontally.</param>
 438     /// <param name="dy">The number of steps vertically.</param>
 439     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 440     virtual public bool MoveDragStep(double dx, double dy) {
 441                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_move_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dx, dy);
 442         Eina.Error.RaiseIfUnhandledException();
 443                                         return _ret_var;
 444  }
 445     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
 446     /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.IDrag.GetDragPage"/>.
 447     ///
 448     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
 449     ///
 450     /// Warning: Paging is bugged!</summary>
 451     /// <param name="dx">The number of pages horizontally.</param>
 452     /// <param name="dy">The number of pages vertically.</param>
 453     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 454     virtual public bool MoveDragPage(double dx, double dy) {
 455                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_move_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dx, dy);
 456         Eina.Error.RaiseIfUnhandledException();
 457                                         return _ret_var;
 458  }
 459     /// <summary>The name and value of the current state of this part (read-only).
 460     /// This is the state name as it appears in EDC description blocks. A state has both a name and a value (double). The default state is &quot;default&quot; 0.0, but this function will return &quot;&quot; if the part is invalid.</summary>
 461     public (System.String, double) State {
 462         get {
 463             System.String _out_state = default(System.String);
 464             double _out_val = default(double);
 465             GetState(out _out_state,out _out_val);
 466             return (_out_state,_out_val);
 467         }
 468     }
 469     /// <summary>Type of this part in the layout.</summary>
 470     /// <value>One of the types or <c>none</c> if not an existing part.</value>
 471     public Efl.Canvas.LayoutPartType PartType {
 472         get { return GetPartType(); }
 473     }
 474     /// <summary>The 2D position of a canvas object.
 475     /// The position is absolute, in pixels, relative to the top-left corner of the window, within its border decorations (application space).
 476     /// (Since EFL 1.22)</summary>
 477     /// <value>A 2D coordinate in pixel units.</value>
 478     public Eina.Position2D Position {
 479         get { return GetPosition(); }
 480         set { SetPosition(value); }
 481     }
 482     /// <summary>The 2D size of a canvas object.
 483     /// (Since EFL 1.22)</summary>
 484     /// <value>A 2D size in pixel units.</value>
 485     public Eina.Size2D Size {
 486         get { return GetSize(); }
 487         set { SetSize(value); }
 488     }
 489     /// <summary>Rectangular geometry that combines both position and size.
 490     /// (Since EFL 1.22)</summary>
 491     /// <value>The X,Y position and W,H size, in pixels.</value>
 492     public Eina.Rect Geometry {
 493         get { return GetGeometry(); }
 494         set { SetGeometry(value); }
 495     }
 496     /// <summary>The visibility of a canvas object.
 497     /// All canvas objects will become visible by default just before render. This means that it is not required to call <see cref="Efl.Gfx.IEntity.SetVisible"/> after creating an object unless you want to create it without showing it. Note that this behavior is new since 1.21, and only applies to canvas objects created with the EO API (i.e. not the legacy C-only API). Other types of Gfx objects may or may not be visible by default.
 498     ///
 499     /// Note that many other parameters can prevent a visible object from actually being &quot;visible&quot; on screen. For instance if its color is fully transparent, or its parent is hidden, or it is clipped out, etc...
 500     /// (Since EFL 1.22)</summary>
 501     /// <value><c>true</c> if to make the object visible, <c>false</c> otherwise</value>
 502     public bool Visible {
 503         get { return GetVisible(); }
 504         set { SetVisible(value); }
 505     }
 506     /// <summary>The scaling factor of an object.
 507     /// This property is an individual scaling factor on the object (Edje or UI widget). This property (or Edje&apos;s global scaling factor, when applicable), will affect this object&apos;s part sizes. If scale is not zero, than the individual scaling will override any global scaling set, for the object obj&apos;s parts. Set it back to zero to get the effects of the global scaling again.
 508     ///
 509     /// Warning: In Edje, only parts which, at EDC level, had the &quot;scale&quot; property set to 1, will be affected by this function. Check the complete &quot;syntax reference&quot; for EDC files.
 510     /// (Since EFL 1.22)</summary>
 511     /// <value>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</value>
 512     public double Scale {
 513         get { return GetScale(); }
 514         set { SetScale(value); }
 515     }
 516     /// <summary>The draggable object relative location.
 517     /// Some parts in Edje can be dragged along the X/Y axes, if the part contains a &quot;draggable&quot; section (in EDC). For instance, scroll bars can be draggable objects.
 518     ///
 519     /// <c>dx</c> and <c>dy</c> are real numbers that range from 0 to 1, representing the relative position to the draggable area on that axis.
 520     ///
 521     /// This value means, for the vertical axis, that 0.0 will be at the top if the first parameter of <c>y</c> in the draggable part theme is 1 and at the bottom if it is -1.
 522     ///
 523     /// For the horizontal axis, 0.0 means left if the first parameter of <c>x</c> in the draggable part theme is 1, and right if it is -1.</summary>
 524     /// <value>The x relative position, from 0 to 1.</value>
 525     public (double, double) DragValue {
 526         get {
 527             double _out_dx = default(double);
 528             double _out_dy = default(double);
 529             GetDragValue(out _out_dx,out _out_dy);
 530             return (_out_dx,_out_dy);
 531         }
 532         set { SetDragValue( value.Item1,  value.Item2); }
 533     }
 534     /// <summary>The draggable object relative size.
 535     /// Values for <c>dw</c> and <c>dh</c> are real numbers that range from 0 to 1, representing the relative size of the draggable area on that axis.
 536     ///
 537     /// For instance a scroll bar handle size may depend on the size of the scroller&apos;s content.</summary>
 538     /// <value>The drag relative width, from 0 to 1.</value>
 539     public (double, double) DragSize {
 540         get {
 541             double _out_dw = default(double);
 542             double _out_dh = default(double);
 543             GetDragSize(out _out_dw,out _out_dh);
 544             return (_out_dw,_out_dh);
 545         }
 546         set { SetDragSize( value.Item1,  value.Item2); }
 547     }
 548     /// <summary>Determines the draggable directions (read-only).
 549     /// The draggable directions are defined in the EDC file, inside the &quot;draggable&quot; section, by the attributes <c>x</c> and <c>y</c>. See the EDC reference documentation for more information.</summary>
 550     /// <value>The direction(s) premitted for drag.</value>
 551     public Efl.Ui.DragDir DragDir {
 552         get { return GetDragDir(); }
 553     }
 554     /// <summary>The drag step increment.
 555     /// Values for <c>dx</c> and <c>dy</c> are real numbers that range from 0 to 1, representing the relative size of the draggable area on that axis by which the part will be moved.
 556     ///
 557     /// This differs from <see cref="Efl.Ui.IDrag.GetDragPage"/> in that this is meant to represent a unit increment, like a single line for example.
 558     ///
 559     /// See also <see cref="Efl.Ui.IDrag.GetDragPage"/>.</summary>
 560     /// <value>The x step relative amount, from 0 to 1.</value>
 561     public (double, double) DragStep {
 562         get {
 563             double _out_dx = default(double);
 564             double _out_dy = default(double);
 565             GetDragStep(out _out_dx,out _out_dy);
 566             return (_out_dx,_out_dy);
 567         }
 568         set { SetDragStep( value.Item1,  value.Item2); }
 569     }
 570     /// <summary>The page step increments.
 571     /// Values for <c>dx</c> and <c>dy</c> are real numbers that range from 0 to 1, representing the relative size of the draggable area on that axis by which the part will be moved.
 572     ///
 573     /// This differs from <see cref="Efl.Ui.IDrag.GetDragStep"/> in that this is meant to be a larger step size, basically an entire page as opposed to a single or couple of lines.
 574     ///
 575     /// See also <see cref="Efl.Ui.IDrag.GetDragStep"/>.</summary>
 576     /// <value>The x page step increment</value>
 577     public (double, double) DragPage {
 578         get {
 579             double _out_dx = default(double);
 580             double _out_dy = default(double);
 581             GetDragPage(out _out_dx,out _out_dy);
 582             return (_out_dx,_out_dy);
 583         }
 584         set { SetDragPage( value.Item1,  value.Item2); }
 585     }
 586     private static IntPtr GetEflClassStatic()
 587     {
 588         return Efl.Canvas.LayoutPart.efl_canvas_layout_part_class_get();
 589     }
 590     /// <summary>Wrapper for native methods and virtual method delegates.
 591     /// For internal use by generated code only.</summary>
 592     public new class NativeMethods : Efl.Object.NativeMethods
 593     {
 594         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 595         /// <summary>Gets the list of Eo operations to override.</summary>
 596         /// <returns>The list of Eo operations to be overload.</returns>
 597         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 598         {
 599             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 600             var methods = Efl.Eo.Globals.GetUserMethods(type);
 601
 602             if (efl_canvas_layout_part_state_get_static_delegate == null)
 603             {
 604                 efl_canvas_layout_part_state_get_static_delegate = new efl_canvas_layout_part_state_get_delegate(state_get);
 605             }
 606
 607             if (methods.FirstOrDefault(m => m.Name == "GetState") != null)
 608             {
 609                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_layout_part_state_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_state_get_static_delegate) });
 610             }
 611
 612             if (efl_canvas_layout_part_type_get_static_delegate == null)
 613             {
 614                 efl_canvas_layout_part_type_get_static_delegate = new efl_canvas_layout_part_type_get_delegate(part_type_get);
 615             }
 616
 617             if (methods.FirstOrDefault(m => m.Name == "GetPartType") != null)
 618             {
 619                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_layout_part_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_type_get_static_delegate) });
 620             }
 621
 622             if (efl_gfx_entity_position_get_static_delegate == null)
 623             {
 624                 efl_gfx_entity_position_get_static_delegate = new efl_gfx_entity_position_get_delegate(position_get);
 625             }
 626
 627             if (methods.FirstOrDefault(m => m.Name == "GetPosition") != null)
 628             {
 629                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_position_get_static_delegate) });
 630             }
 631
 632             if (efl_gfx_entity_position_set_static_delegate == null)
 633             {
 634                 efl_gfx_entity_position_set_static_delegate = new efl_gfx_entity_position_set_delegate(position_set);
 635             }
 636
 637             if (methods.FirstOrDefault(m => m.Name == "SetPosition") != null)
 638             {
 639                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_position_set_static_delegate) });
 640             }
 641
 642             if (efl_gfx_entity_size_get_static_delegate == null)
 643             {
 644                 efl_gfx_entity_size_get_static_delegate = new efl_gfx_entity_size_get_delegate(size_get);
 645             }
 646
 647             if (methods.FirstOrDefault(m => m.Name == "GetSize") != null)
 648             {
 649                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_size_get_static_delegate) });
 650             }
 651
 652             if (efl_gfx_entity_size_set_static_delegate == null)
 653             {
 654                 efl_gfx_entity_size_set_static_delegate = new efl_gfx_entity_size_set_delegate(size_set);
 655             }
 656
 657             if (methods.FirstOrDefault(m => m.Name == "SetSize") != null)
 658             {
 659                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_size_set_static_delegate) });
 660             }
 661
 662             if (efl_gfx_entity_geometry_get_static_delegate == null)
 663             {
 664                 efl_gfx_entity_geometry_get_static_delegate = new efl_gfx_entity_geometry_get_delegate(geometry_get);
 665             }
 666
 667             if (methods.FirstOrDefault(m => m.Name == "GetGeometry") != null)
 668             {
 669                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_geometry_get_static_delegate) });
 670             }
 671
 672             if (efl_gfx_entity_geometry_set_static_delegate == null)
 673             {
 674                 efl_gfx_entity_geometry_set_static_delegate = new efl_gfx_entity_geometry_set_delegate(geometry_set);
 675             }
 676
 677             if (methods.FirstOrDefault(m => m.Name == "SetGeometry") != null)
 678             {
 679                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_geometry_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_geometry_set_static_delegate) });
 680             }
 681
 682             if (efl_gfx_entity_visible_get_static_delegate == null)
 683             {
 684                 efl_gfx_entity_visible_get_static_delegate = new efl_gfx_entity_visible_get_delegate(visible_get);
 685             }
 686
 687             if (methods.FirstOrDefault(m => m.Name == "GetVisible") != null)
 688             {
 689                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_visible_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_visible_get_static_delegate) });
 690             }
 691
 692             if (efl_gfx_entity_visible_set_static_delegate == null)
 693             {
 694                 efl_gfx_entity_visible_set_static_delegate = new efl_gfx_entity_visible_set_delegate(visible_set);
 695             }
 696
 697             if (methods.FirstOrDefault(m => m.Name == "SetVisible") != null)
 698             {
 699                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_visible_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_visible_set_static_delegate) });
 700             }
 701
 702             if (efl_gfx_entity_scale_get_static_delegate == null)
 703             {
 704                 efl_gfx_entity_scale_get_static_delegate = new efl_gfx_entity_scale_get_delegate(scale_get);
 705             }
 706
 707             if (methods.FirstOrDefault(m => m.Name == "GetScale") != null)
 708             {
 709                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_scale_get_static_delegate) });
 710             }
 711
 712             if (efl_gfx_entity_scale_set_static_delegate == null)
 713             {
 714                 efl_gfx_entity_scale_set_static_delegate = new efl_gfx_entity_scale_set_delegate(scale_set);
 715             }
 716
 717             if (methods.FirstOrDefault(m => m.Name == "SetScale") != null)
 718             {
 719                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_entity_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_entity_scale_set_static_delegate) });
 720             }
 721
 722             if (efl_ui_drag_value_get_static_delegate == null)
 723             {
 724                 efl_ui_drag_value_get_static_delegate = new efl_ui_drag_value_get_delegate(drag_value_get);
 725             }
 726
 727             if (methods.FirstOrDefault(m => m.Name == "GetDragValue") != null)
 728             {
 729                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_value_get_static_delegate) });
 730             }
 731
 732             if (efl_ui_drag_value_set_static_delegate == null)
 733             {
 734                 efl_ui_drag_value_set_static_delegate = new efl_ui_drag_value_set_delegate(drag_value_set);
 735             }
 736
 737             if (methods.FirstOrDefault(m => m.Name == "SetDragValue") != null)
 738             {
 739                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_value_set_static_delegate) });
 740             }
 741
 742             if (efl_ui_drag_size_get_static_delegate == null)
 743             {
 744                 efl_ui_drag_size_get_static_delegate = new efl_ui_drag_size_get_delegate(drag_size_get);
 745             }
 746
 747             if (methods.FirstOrDefault(m => m.Name == "GetDragSize") != null)
 748             {
 749                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_size_get_static_delegate) });
 750             }
 751
 752             if (efl_ui_drag_size_set_static_delegate == null)
 753             {
 754                 efl_ui_drag_size_set_static_delegate = new efl_ui_drag_size_set_delegate(drag_size_set);
 755             }
 756
 757             if (methods.FirstOrDefault(m => m.Name == "SetDragSize") != null)
 758             {
 759                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_size_set_static_delegate) });
 760             }
 761
 762             if (efl_ui_drag_dir_get_static_delegate == null)
 763             {
 764                 efl_ui_drag_dir_get_static_delegate = new efl_ui_drag_dir_get_delegate(drag_dir_get);
 765             }
 766
 767             if (methods.FirstOrDefault(m => m.Name == "GetDragDir") != null)
 768             {
 769                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_dir_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_dir_get_static_delegate) });
 770             }
 771
 772             if (efl_ui_drag_step_get_static_delegate == null)
 773             {
 774                 efl_ui_drag_step_get_static_delegate = new efl_ui_drag_step_get_delegate(drag_step_get);
 775             }
 776
 777             if (methods.FirstOrDefault(m => m.Name == "GetDragStep") != null)
 778             {
 779                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_step_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_get_static_delegate) });
 780             }
 781
 782             if (efl_ui_drag_step_set_static_delegate == null)
 783             {
 784                 efl_ui_drag_step_set_static_delegate = new efl_ui_drag_step_set_delegate(drag_step_set);
 785             }
 786
 787             if (methods.FirstOrDefault(m => m.Name == "SetDragStep") != null)
 788             {
 789                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_step_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_set_static_delegate) });
 790             }
 791
 792             if (efl_ui_drag_page_get_static_delegate == null)
 793             {
 794                 efl_ui_drag_page_get_static_delegate = new efl_ui_drag_page_get_delegate(drag_page_get);
 795             }
 796
 797             if (methods.FirstOrDefault(m => m.Name == "GetDragPage") != null)
 798             {
 799                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_page_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_get_static_delegate) });
 800             }
 801
 802             if (efl_ui_drag_page_set_static_delegate == null)
 803             {
 804                 efl_ui_drag_page_set_static_delegate = new efl_ui_drag_page_set_delegate(drag_page_set);
 805             }
 806
 807             if (methods.FirstOrDefault(m => m.Name == "SetDragPage") != null)
 808             {
 809                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_page_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_set_static_delegate) });
 810             }
 811
 812             if (efl_ui_drag_step_move_static_delegate == null)
 813             {
 814                 efl_ui_drag_step_move_static_delegate = new efl_ui_drag_step_move_delegate(drag_step_move);
 815             }
 816
 817             if (methods.FirstOrDefault(m => m.Name == "MoveDragStep") != null)
 818             {
 819                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_step_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_move_static_delegate) });
 820             }
 821
 822             if (efl_ui_drag_page_move_static_delegate == null)
 823             {
 824                 efl_ui_drag_page_move_static_delegate = new efl_ui_drag_page_move_delegate(drag_page_move);
 825             }
 826
 827             if (methods.FirstOrDefault(m => m.Name == "MoveDragPage") != null)
 828             {
 829                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_drag_page_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_move_static_delegate) });
 830             }
 831
 832             descs.AddRange(base.GetEoOps(type));
 833             return descs;
 834         }
 835         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 836         /// <returns>The native class pointer.</returns>
 837         public override IntPtr GetEflClass()
 838         {
 839             return Efl.Canvas.LayoutPart.efl_canvas_layout_part_class_get();
 840         }
 841
 842         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 843
 844
 845         private delegate void efl_canvas_layout_part_state_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String state,  out double val);
 846
 847
 848         public delegate void efl_canvas_layout_part_state_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String state,  out double val);
 849
 850         public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_state_get_api_delegate> efl_canvas_layout_part_state_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_state_get_api_delegate>(Module, "efl_canvas_layout_part_state_get");
 851
 852         private static void state_get(System.IntPtr obj, System.IntPtr pd, out System.String state, out double val)
 853         {
 854             Eina.Log.Debug("function efl_canvas_layout_part_state_get was called");
 855             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 856             if (ws != null)
 857             {
 858                         System.String _out_state = default(System.String);
 859         val = default(double);
 860                 try
 861                 {
 862                     ((LayoutPart)ws.Target).GetState(out _out_state, out val);
 863                 }
 864                 catch (Exception e)
 865                 {
 866                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 867                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 868                 }
 869
 870         state = _out_state;
 871
 872             }
 873             else
 874             {
 875                 efl_canvas_layout_part_state_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out state, out val);
 876             }
 877         }
 878
 879         private static efl_canvas_layout_part_state_get_delegate efl_canvas_layout_part_state_get_static_delegate;
 880
 881
 882         private delegate Efl.Canvas.LayoutPartType efl_canvas_layout_part_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 883
 884
 885         public delegate Efl.Canvas.LayoutPartType efl_canvas_layout_part_type_get_api_delegate(System.IntPtr obj);
 886
 887         public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_type_get_api_delegate> efl_canvas_layout_part_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_type_get_api_delegate>(Module, "efl_canvas_layout_part_type_get");
 888
 889         private static Efl.Canvas.LayoutPartType part_type_get(System.IntPtr obj, System.IntPtr pd)
 890         {
 891             Eina.Log.Debug("function efl_canvas_layout_part_type_get was called");
 892             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 893             if (ws != null)
 894             {
 895             Efl.Canvas.LayoutPartType _ret_var = default(Efl.Canvas.LayoutPartType);
 896                 try
 897                 {
 898                     _ret_var = ((LayoutPart)ws.Target).GetPartType();
 899                 }
 900                 catch (Exception e)
 901                 {
 902                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 903                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 904                 }
 905
 906         return _ret_var;
 907
 908             }
 909             else
 910             {
 911                 return efl_canvas_layout_part_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 912             }
 913         }
 914
 915         private static efl_canvas_layout_part_type_get_delegate efl_canvas_layout_part_type_get_static_delegate;
 916
 917
 918         private delegate Eina.Position2D.NativeStruct efl_gfx_entity_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
 919
 920
 921         public delegate Eina.Position2D.NativeStruct efl_gfx_entity_position_get_api_delegate(System.IntPtr obj);
 922
 923         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_position_get_api_delegate> efl_gfx_entity_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_position_get_api_delegate>(Module, "efl_gfx_entity_position_get");
 924
 925         private static Eina.Position2D.NativeStruct position_get(System.IntPtr obj, System.IntPtr pd)
 926         {
 927             Eina.Log.Debug("function efl_gfx_entity_position_get was called");
 928             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 929             if (ws != null)
 930             {
 931             Eina.Position2D _ret_var = default(Eina.Position2D);
 932                 try
 933                 {
 934                     _ret_var = ((LayoutPart)ws.Target).GetPosition();
 935                 }
 936                 catch (Exception e)
 937                 {
 938                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 939                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 940                 }
 941
 942         return _ret_var;
 943
 944             }
 945             else
 946             {
 947                 return efl_gfx_entity_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 948             }
 949         }
 950
 951         private static efl_gfx_entity_position_get_delegate efl_gfx_entity_position_get_static_delegate;
 952
 953
 954         private delegate void efl_gfx_entity_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
 955
 956
 957         public delegate void efl_gfx_entity_position_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
 958
 959         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_position_set_api_delegate> efl_gfx_entity_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_position_set_api_delegate>(Module, "efl_gfx_entity_position_set");
 960
 961         private static void position_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
 962         {
 963             Eina.Log.Debug("function efl_gfx_entity_position_set was called");
 964             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 965             if (ws != null)
 966             {
 967         Eina.Position2D _in_pos = pos;
 968
 969                 try
 970                 {
 971                     ((LayoutPart)ws.Target).SetPosition(_in_pos);
 972                 }
 973                 catch (Exception e)
 974                 {
 975                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 976                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 977                 }
 978
 979
 980             }
 981             else
 982             {
 983                 efl_gfx_entity_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
 984             }
 985         }
 986
 987         private static efl_gfx_entity_position_set_delegate efl_gfx_entity_position_set_static_delegate;
 988
 989
 990         private delegate Eina.Size2D.NativeStruct efl_gfx_entity_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 991
 992
 993         public delegate Eina.Size2D.NativeStruct efl_gfx_entity_size_get_api_delegate(System.IntPtr obj);
 994
 995         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_size_get_api_delegate> efl_gfx_entity_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_size_get_api_delegate>(Module, "efl_gfx_entity_size_get");
 996
 997         private static Eina.Size2D.NativeStruct size_get(System.IntPtr obj, System.IntPtr pd)
 998         {
 999             Eina.Log.Debug("function efl_gfx_entity_size_get was called");
1000             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1001             if (ws != null)
1002             {
1003             Eina.Size2D _ret_var = default(Eina.Size2D);
1004                 try
1005                 {
1006                     _ret_var = ((LayoutPart)ws.Target).GetSize();
1007                 }
1008                 catch (Exception e)
1009                 {
1010                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1011                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1012                 }
1013
1014         return _ret_var;
1015
1016             }
1017             else
1018             {
1019                 return efl_gfx_entity_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1020             }
1021         }
1022
1023         private static efl_gfx_entity_size_get_delegate efl_gfx_entity_size_get_static_delegate;
1024
1025
1026         private delegate void efl_gfx_entity_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
1027
1028
1029         public delegate void efl_gfx_entity_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
1030
1031         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_size_set_api_delegate> efl_gfx_entity_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_size_set_api_delegate>(Module, "efl_gfx_entity_size_set");
1032
1033         private static void size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
1034         {
1035             Eina.Log.Debug("function efl_gfx_entity_size_set was called");
1036             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1037             if (ws != null)
1038             {
1039         Eina.Size2D _in_size = size;
1040
1041                 try
1042                 {
1043                     ((LayoutPart)ws.Target).SetSize(_in_size);
1044                 }
1045                 catch (Exception e)
1046                 {
1047                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1048                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1049                 }
1050
1051
1052             }
1053             else
1054             {
1055                 efl_gfx_entity_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
1056             }
1057         }
1058
1059         private static efl_gfx_entity_size_set_delegate efl_gfx_entity_size_set_static_delegate;
1060
1061
1062         private delegate Eina.Rect.NativeStruct efl_gfx_entity_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
1063
1064
1065         public delegate Eina.Rect.NativeStruct efl_gfx_entity_geometry_get_api_delegate(System.IntPtr obj);
1066
1067         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_geometry_get_api_delegate> efl_gfx_entity_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_geometry_get_api_delegate>(Module, "efl_gfx_entity_geometry_get");
1068
1069         private static Eina.Rect.NativeStruct geometry_get(System.IntPtr obj, System.IntPtr pd)
1070         {
1071             Eina.Log.Debug("function efl_gfx_entity_geometry_get was called");
1072             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1073             if (ws != null)
1074             {
1075             Eina.Rect _ret_var = default(Eina.Rect);
1076                 try
1077                 {
1078                     _ret_var = ((LayoutPart)ws.Target).GetGeometry();
1079                 }
1080                 catch (Exception e)
1081                 {
1082                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1083                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1084                 }
1085
1086         return _ret_var;
1087
1088             }
1089             else
1090             {
1091                 return efl_gfx_entity_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1092             }
1093         }
1094
1095         private static efl_gfx_entity_geometry_get_delegate efl_gfx_entity_geometry_get_static_delegate;
1096
1097
1098         private delegate void efl_gfx_entity_geometry_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect);
1099
1100
1101         public delegate void efl_gfx_entity_geometry_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect);
1102
1103         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_geometry_set_api_delegate> efl_gfx_entity_geometry_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_geometry_set_api_delegate>(Module, "efl_gfx_entity_geometry_set");
1104
1105         private static void geometry_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect)
1106         {
1107             Eina.Log.Debug("function efl_gfx_entity_geometry_set was called");
1108             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1109             if (ws != null)
1110             {
1111         Eina.Rect _in_rect = rect;
1112
1113                 try
1114                 {
1115                     ((LayoutPart)ws.Target).SetGeometry(_in_rect);
1116                 }
1117                 catch (Exception e)
1118                 {
1119                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1120                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1121                 }
1122
1123
1124             }
1125             else
1126             {
1127                 efl_gfx_entity_geometry_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect);
1128             }
1129         }
1130
1131         private static efl_gfx_entity_geometry_set_delegate efl_gfx_entity_geometry_set_static_delegate;
1132
1133         [return: MarshalAs(UnmanagedType.U1)]
1134         private delegate bool efl_gfx_entity_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
1135
1136         [return: MarshalAs(UnmanagedType.U1)]
1137         public delegate bool efl_gfx_entity_visible_get_api_delegate(System.IntPtr obj);
1138
1139         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_visible_get_api_delegate> efl_gfx_entity_visible_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_visible_get_api_delegate>(Module, "efl_gfx_entity_visible_get");
1140
1141         private static bool visible_get(System.IntPtr obj, System.IntPtr pd)
1142         {
1143             Eina.Log.Debug("function efl_gfx_entity_visible_get was called");
1144             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1145             if (ws != null)
1146             {
1147             bool _ret_var = default(bool);
1148                 try
1149                 {
1150                     _ret_var = ((LayoutPart)ws.Target).GetVisible();
1151                 }
1152                 catch (Exception e)
1153                 {
1154                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1155                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1156                 }
1157
1158         return _ret_var;
1159
1160             }
1161             else
1162             {
1163                 return efl_gfx_entity_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1164             }
1165         }
1166
1167         private static efl_gfx_entity_visible_get_delegate efl_gfx_entity_visible_get_static_delegate;
1168
1169
1170         private delegate void efl_gfx_entity_visible_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool v);
1171
1172
1173         public delegate void efl_gfx_entity_visible_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool v);
1174
1175         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_visible_set_api_delegate> efl_gfx_entity_visible_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_visible_set_api_delegate>(Module, "efl_gfx_entity_visible_set");
1176
1177         private static void visible_set(System.IntPtr obj, System.IntPtr pd, bool v)
1178         {
1179             Eina.Log.Debug("function efl_gfx_entity_visible_set was called");
1180             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1181             if (ws != null)
1182             {
1183
1184                 try
1185                 {
1186                     ((LayoutPart)ws.Target).SetVisible(v);
1187                 }
1188                 catch (Exception e)
1189                 {
1190                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1191                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1192                 }
1193
1194
1195             }
1196             else
1197             {
1198                 efl_gfx_entity_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), v);
1199             }
1200         }
1201
1202         private static efl_gfx_entity_visible_set_delegate efl_gfx_entity_visible_set_static_delegate;
1203
1204
1205         private delegate double efl_gfx_entity_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1206
1207
1208         public delegate double efl_gfx_entity_scale_get_api_delegate(System.IntPtr obj);
1209
1210         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_scale_get_api_delegate> efl_gfx_entity_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_scale_get_api_delegate>(Module, "efl_gfx_entity_scale_get");
1211
1212         private static double scale_get(System.IntPtr obj, System.IntPtr pd)
1213         {
1214             Eina.Log.Debug("function efl_gfx_entity_scale_get was called");
1215             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1216             if (ws != null)
1217             {
1218             double _ret_var = default(double);
1219                 try
1220                 {
1221                     _ret_var = ((LayoutPart)ws.Target).GetScale();
1222                 }
1223                 catch (Exception e)
1224                 {
1225                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1226                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1227                 }
1228
1229         return _ret_var;
1230
1231             }
1232             else
1233             {
1234                 return efl_gfx_entity_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1235             }
1236         }
1237
1238         private static efl_gfx_entity_scale_get_delegate efl_gfx_entity_scale_get_static_delegate;
1239
1240
1241         private delegate void efl_gfx_entity_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
1242
1243
1244         public delegate void efl_gfx_entity_scale_set_api_delegate(System.IntPtr obj,  double scale);
1245
1246         public static Efl.Eo.FunctionWrapper<efl_gfx_entity_scale_set_api_delegate> efl_gfx_entity_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_entity_scale_set_api_delegate>(Module, "efl_gfx_entity_scale_set");
1247
1248         private static void scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
1249         {
1250             Eina.Log.Debug("function efl_gfx_entity_scale_set was called");
1251             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1252             if (ws != null)
1253             {
1254
1255                 try
1256                 {
1257                     ((LayoutPart)ws.Target).SetScale(scale);
1258                 }
1259                 catch (Exception e)
1260                 {
1261                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1262                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1263                 }
1264
1265
1266             }
1267             else
1268             {
1269                 efl_gfx_entity_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
1270             }
1271         }
1272
1273         private static efl_gfx_entity_scale_set_delegate efl_gfx_entity_scale_set_static_delegate;
1274
1275         [return: MarshalAs(UnmanagedType.U1)]
1276         private delegate bool efl_ui_drag_value_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
1277
1278         [return: MarshalAs(UnmanagedType.U1)]
1279         public delegate bool efl_ui_drag_value_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
1280
1281         public static Efl.Eo.FunctionWrapper<efl_ui_drag_value_get_api_delegate> efl_ui_drag_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_value_get_api_delegate>(Module, "efl_ui_drag_value_get");
1282
1283         private static bool drag_value_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
1284         {
1285             Eina.Log.Debug("function efl_ui_drag_value_get was called");
1286             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1287             if (ws != null)
1288             {
1289                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
1290                 try
1291                 {
1292                     _ret_var = ((LayoutPart)ws.Target).GetDragValue(out dx, out dy);
1293                 }
1294                 catch (Exception e)
1295                 {
1296                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1297                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1298                 }
1299
1300                                         return _ret_var;
1301
1302             }
1303             else
1304             {
1305                 return efl_ui_drag_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out dx, out dy);
1306             }
1307         }
1308
1309         private static efl_ui_drag_value_get_delegate efl_ui_drag_value_get_static_delegate;
1310
1311         [return: MarshalAs(UnmanagedType.U1)]
1312         private delegate bool efl_ui_drag_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
1313
1314         [return: MarshalAs(UnmanagedType.U1)]
1315         public delegate bool efl_ui_drag_value_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
1316
1317         public static Efl.Eo.FunctionWrapper<efl_ui_drag_value_set_api_delegate> efl_ui_drag_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_value_set_api_delegate>(Module, "efl_ui_drag_value_set");
1318
1319         private static bool drag_value_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
1320         {
1321             Eina.Log.Debug("function efl_ui_drag_value_set was called");
1322             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1323             if (ws != null)
1324             {
1325                                                             bool _ret_var = default(bool);
1326                 try
1327                 {
1328                     _ret_var = ((LayoutPart)ws.Target).SetDragValue(dx, dy);
1329                 }
1330                 catch (Exception e)
1331                 {
1332                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1333                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1334                 }
1335
1336                                         return _ret_var;
1337
1338             }
1339             else
1340             {
1341                 return efl_ui_drag_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
1342             }
1343         }
1344
1345         private static efl_ui_drag_value_set_delegate efl_ui_drag_value_set_static_delegate;
1346
1347         [return: MarshalAs(UnmanagedType.U1)]
1348         private delegate bool efl_ui_drag_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dw,  out double dh);
1349
1350         [return: MarshalAs(UnmanagedType.U1)]
1351         public delegate bool efl_ui_drag_size_get_api_delegate(System.IntPtr obj,  out double dw,  out double dh);
1352
1353         public static Efl.Eo.FunctionWrapper<efl_ui_drag_size_get_api_delegate> efl_ui_drag_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_size_get_api_delegate>(Module, "efl_ui_drag_size_get");
1354
1355         private static bool drag_size_get(System.IntPtr obj, System.IntPtr pd, out double dw, out double dh)
1356         {
1357             Eina.Log.Debug("function efl_ui_drag_size_get was called");
1358             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1359             if (ws != null)
1360             {
1361                         dw = default(double);        dh = default(double);                            bool _ret_var = default(bool);
1362                 try
1363                 {
1364                     _ret_var = ((LayoutPart)ws.Target).GetDragSize(out dw, out dh);
1365                 }
1366                 catch (Exception e)
1367                 {
1368                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1369                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1370                 }
1371
1372                                         return _ret_var;
1373
1374             }
1375             else
1376             {
1377                 return efl_ui_drag_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out dw, out dh);
1378             }
1379         }
1380
1381         private static efl_ui_drag_size_get_delegate efl_ui_drag_size_get_static_delegate;
1382
1383         [return: MarshalAs(UnmanagedType.U1)]
1384         private delegate bool efl_ui_drag_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dw,  double dh);
1385
1386         [return: MarshalAs(UnmanagedType.U1)]
1387         public delegate bool efl_ui_drag_size_set_api_delegate(System.IntPtr obj,  double dw,  double dh);
1388
1389         public static Efl.Eo.FunctionWrapper<efl_ui_drag_size_set_api_delegate> efl_ui_drag_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_size_set_api_delegate>(Module, "efl_ui_drag_size_set");
1390
1391         private static bool drag_size_set(System.IntPtr obj, System.IntPtr pd, double dw, double dh)
1392         {
1393             Eina.Log.Debug("function efl_ui_drag_size_set was called");
1394             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1395             if (ws != null)
1396             {
1397                                                             bool _ret_var = default(bool);
1398                 try
1399                 {
1400                     _ret_var = ((LayoutPart)ws.Target).SetDragSize(dw, dh);
1401                 }
1402                 catch (Exception e)
1403                 {
1404                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1405                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1406                 }
1407
1408                                         return _ret_var;
1409
1410             }
1411             else
1412             {
1413                 return efl_ui_drag_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dw, dh);
1414             }
1415         }
1416
1417         private static efl_ui_drag_size_set_delegate efl_ui_drag_size_set_static_delegate;
1418
1419
1420         private delegate Efl.Ui.DragDir efl_ui_drag_dir_get_delegate(System.IntPtr obj, System.IntPtr pd);
1421
1422
1423         public delegate Efl.Ui.DragDir efl_ui_drag_dir_get_api_delegate(System.IntPtr obj);
1424
1425         public static Efl.Eo.FunctionWrapper<efl_ui_drag_dir_get_api_delegate> efl_ui_drag_dir_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_dir_get_api_delegate>(Module, "efl_ui_drag_dir_get");
1426
1427         private static Efl.Ui.DragDir drag_dir_get(System.IntPtr obj, System.IntPtr pd)
1428         {
1429             Eina.Log.Debug("function efl_ui_drag_dir_get was called");
1430             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1431             if (ws != null)
1432             {
1433             Efl.Ui.DragDir _ret_var = default(Efl.Ui.DragDir);
1434                 try
1435                 {
1436                     _ret_var = ((LayoutPart)ws.Target).GetDragDir();
1437                 }
1438                 catch (Exception e)
1439                 {
1440                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1441                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1442                 }
1443
1444         return _ret_var;
1445
1446             }
1447             else
1448             {
1449                 return efl_ui_drag_dir_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1450             }
1451         }
1452
1453         private static efl_ui_drag_dir_get_delegate efl_ui_drag_dir_get_static_delegate;
1454
1455         [return: MarshalAs(UnmanagedType.U1)]
1456         private delegate bool efl_ui_drag_step_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
1457
1458         [return: MarshalAs(UnmanagedType.U1)]
1459         public delegate bool efl_ui_drag_step_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
1460
1461         public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_get_api_delegate> efl_ui_drag_step_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_get_api_delegate>(Module, "efl_ui_drag_step_get");
1462
1463         private static bool drag_step_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
1464         {
1465             Eina.Log.Debug("function efl_ui_drag_step_get was called");
1466             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1467             if (ws != null)
1468             {
1469                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
1470                 try
1471                 {
1472                     _ret_var = ((LayoutPart)ws.Target).GetDragStep(out dx, out dy);
1473                 }
1474                 catch (Exception e)
1475                 {
1476                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1477                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1478                 }
1479
1480                                         return _ret_var;
1481
1482             }
1483             else
1484             {
1485                 return efl_ui_drag_step_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out dx, out dy);
1486             }
1487         }
1488
1489         private static efl_ui_drag_step_get_delegate efl_ui_drag_step_get_static_delegate;
1490
1491         [return: MarshalAs(UnmanagedType.U1)]
1492         private delegate bool efl_ui_drag_step_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
1493
1494         [return: MarshalAs(UnmanagedType.U1)]
1495         public delegate bool efl_ui_drag_step_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
1496
1497         public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_set_api_delegate> efl_ui_drag_step_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_set_api_delegate>(Module, "efl_ui_drag_step_set");
1498
1499         private static bool drag_step_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
1500         {
1501             Eina.Log.Debug("function efl_ui_drag_step_set was called");
1502             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1503             if (ws != null)
1504             {
1505                                                             bool _ret_var = default(bool);
1506                 try
1507                 {
1508                     _ret_var = ((LayoutPart)ws.Target).SetDragStep(dx, dy);
1509                 }
1510                 catch (Exception e)
1511                 {
1512                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1513                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1514                 }
1515
1516                                         return _ret_var;
1517
1518             }
1519             else
1520             {
1521                 return efl_ui_drag_step_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
1522             }
1523         }
1524
1525         private static efl_ui_drag_step_set_delegate efl_ui_drag_step_set_static_delegate;
1526
1527         [return: MarshalAs(UnmanagedType.U1)]
1528         private delegate bool efl_ui_drag_page_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
1529
1530         [return: MarshalAs(UnmanagedType.U1)]
1531         public delegate bool efl_ui_drag_page_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
1532
1533         public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_get_api_delegate> efl_ui_drag_page_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_get_api_delegate>(Module, "efl_ui_drag_page_get");
1534
1535         private static bool drag_page_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
1536         {
1537             Eina.Log.Debug("function efl_ui_drag_page_get was called");
1538             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1539             if (ws != null)
1540             {
1541                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
1542                 try
1543                 {
1544                     _ret_var = ((LayoutPart)ws.Target).GetDragPage(out dx, out dy);
1545                 }
1546                 catch (Exception e)
1547                 {
1548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1550                 }
1551
1552                                         return _ret_var;
1553
1554             }
1555             else
1556             {
1557                 return efl_ui_drag_page_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out dx, out dy);
1558             }
1559         }
1560
1561         private static efl_ui_drag_page_get_delegate efl_ui_drag_page_get_static_delegate;
1562
1563         [return: MarshalAs(UnmanagedType.U1)]
1564         private delegate bool efl_ui_drag_page_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
1565
1566         [return: MarshalAs(UnmanagedType.U1)]
1567         public delegate bool efl_ui_drag_page_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
1568
1569         public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_set_api_delegate> efl_ui_drag_page_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_set_api_delegate>(Module, "efl_ui_drag_page_set");
1570
1571         private static bool drag_page_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
1572         {
1573             Eina.Log.Debug("function efl_ui_drag_page_set was called");
1574             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1575             if (ws != null)
1576             {
1577                                                             bool _ret_var = default(bool);
1578                 try
1579                 {
1580                     _ret_var = ((LayoutPart)ws.Target).SetDragPage(dx, dy);
1581                 }
1582                 catch (Exception e)
1583                 {
1584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1586                 }
1587
1588                                         return _ret_var;
1589
1590             }
1591             else
1592             {
1593                 return efl_ui_drag_page_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
1594             }
1595         }
1596
1597         private static efl_ui_drag_page_set_delegate efl_ui_drag_page_set_static_delegate;
1598
1599         [return: MarshalAs(UnmanagedType.U1)]
1600         private delegate bool efl_ui_drag_step_move_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
1601
1602         [return: MarshalAs(UnmanagedType.U1)]
1603         public delegate bool efl_ui_drag_step_move_api_delegate(System.IntPtr obj,  double dx,  double dy);
1604
1605         public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_move_api_delegate> efl_ui_drag_step_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_move_api_delegate>(Module, "efl_ui_drag_step_move");
1606
1607         private static bool drag_step_move(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
1608         {
1609             Eina.Log.Debug("function efl_ui_drag_step_move was called");
1610             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1611             if (ws != null)
1612             {
1613                                                             bool _ret_var = default(bool);
1614                 try
1615                 {
1616                     _ret_var = ((LayoutPart)ws.Target).MoveDragStep(dx, dy);
1617                 }
1618                 catch (Exception e)
1619                 {
1620                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1621                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1622                 }
1623
1624                                         return _ret_var;
1625
1626             }
1627             else
1628             {
1629                 return efl_ui_drag_step_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
1630             }
1631         }
1632
1633         private static efl_ui_drag_step_move_delegate efl_ui_drag_step_move_static_delegate;
1634
1635         [return: MarshalAs(UnmanagedType.U1)]
1636         private delegate bool efl_ui_drag_page_move_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
1637
1638         [return: MarshalAs(UnmanagedType.U1)]
1639         public delegate bool efl_ui_drag_page_move_api_delegate(System.IntPtr obj,  double dx,  double dy);
1640
1641         public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_move_api_delegate> efl_ui_drag_page_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_move_api_delegate>(Module, "efl_ui_drag_page_move");
1642
1643         private static bool drag_page_move(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
1644         {
1645             Eina.Log.Debug("function efl_ui_drag_page_move was called");
1646             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1647             if (ws != null)
1648             {
1649                                                             bool _ret_var = default(bool);
1650                 try
1651                 {
1652                     _ret_var = ((LayoutPart)ws.Target).MoveDragPage(dx, dy);
1653                 }
1654                 catch (Exception e)
1655                 {
1656                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1657                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1658                 }
1659
1660                                         return _ret_var;
1661
1662             }
1663             else
1664             {
1665                 return efl_ui_drag_page_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
1666             }
1667         }
1668
1669         private static efl_ui_drag_page_move_delegate efl_ui_drag_page_move_static_delegate;
1670
1671         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1672
1673 }
1674 }
1675 }
1676
1677 }
1678
1679 #if EFL_BETA
1680 #pragma warning disable CS1591
1681 public static class Efl_CanvasLayoutPart_ExtensionMethods {
1682
1683
1684     public static Efl.BindableProperty<Eina.Position2D> Position<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.LayoutPart, T>magic = null) where T : Efl.Canvas.LayoutPart {
1685         return new Efl.BindableProperty<Eina.Position2D>("position", fac);
1686     }
1687
1688     public static Efl.BindableProperty<Eina.Size2D> Size<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.LayoutPart, T>magic = null) where T : Efl.Canvas.LayoutPart {
1689         return new Efl.BindableProperty<Eina.Size2D>("size", fac);
1690     }
1691
1692     public static Efl.BindableProperty<Eina.Rect> Geometry<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.LayoutPart, T>magic = null) where T : Efl.Canvas.LayoutPart {
1693         return new Efl.BindableProperty<Eina.Rect>("geometry", fac);
1694     }
1695
1696     public static Efl.BindableProperty<bool> Visible<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.LayoutPart, T>magic = null) where T : Efl.Canvas.LayoutPart {
1697         return new Efl.BindableProperty<bool>("visible", fac);
1698     }
1699
1700     public static Efl.BindableProperty<double> Scale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.LayoutPart, T>magic = null) where T : Efl.Canvas.LayoutPart {
1701         return new Efl.BindableProperty<double>("scale", fac);
1702     }
1703
1704
1705
1706
1707
1708
1709 }
1710 #pragma warning restore CS1591
1711 #endif