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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Canvas {
   8 /// <summary>Common class for part proxy objects for <see cref="Efl.Canvas.Layout"/>.
   9 /// As an <see cref="Efl.Part"/> 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();
  10 /// 1.20</summary>
  11 [LayoutPartNativeInherit]
  12 public class LayoutPart : Efl.Object, Efl.Eo.IWrapper,Efl.Gfx.Entity,Efl.Ui.Drag
  13 {
  14    public new static System.IntPtr klass = System.IntPtr.Zero;
  15    public new static Efl.Canvas.LayoutPartNativeInherit nativeInherit = new Efl.Canvas.LayoutPartNativeInherit();
  16    ///<summary>Pointer to the native class description.</summary>
  17    public override System.IntPtr NativeClass {
  18       get {
  19          if (((object)this).GetType() == typeof (LayoutPart))
  20             return Efl.Canvas.LayoutPartNativeInherit.GetEflClassStatic();
  21          else
  22             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  23       }
  24    }
  25    [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  26       efl_canvas_layout_part_class_get();
  27    ///<summary>Creates a new instance.</summary>
  28    ///<param name="parent">Parent instance.</param>
  29    public LayoutPart(Efl.Object parent= null
  30          ) :
  31       base(efl_canvas_layout_part_class_get(), typeof(LayoutPart), parent)
  32    {
  33       FinishInstantiation();
  34    }
  35    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  36    public LayoutPart(System.IntPtr raw) : base(raw)
  37    {
  38             register_event_proxies();
  39    }
  40    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  41    protected LayoutPart(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  42    ///<summary>Casts obj into an instance of this type.</summary>
  43    public new static LayoutPart static_cast(Efl.Object obj)
  44    {
  45       if (obj == null)
  46          throw new System.ArgumentNullException("obj");
  47       return new LayoutPart(obj.NativeHandle);
  48    }
  49    ///<summary>Verifies if the given object is equal to this one.</summary>
  50    public override bool Equals(object obj)
  51    {
  52       var other = obj as Efl.Object;
  53       if (other == null)
  54          return false;
  55       return this.NativeHandle == other.NativeHandle;
  56    }
  57    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  58    public override int GetHashCode()
  59    {
  60       return this.NativeHandle.ToInt32();
  61    }
  62    ///<summary>Turns the native pointer into a string representation.</summary>
  63    public override String ToString()
  64    {
  65       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  66    }
  67 private static object VisibilityChangedEvtKey = new object();
  68    /// <summary>Object&apos;s visibility state changed, the event value is the new state.</summary>
  69    public event EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args> VisibilityChangedEvt
  70    {
  71       add {
  72          lock (eventLock) {
  73             string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
  74             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_VisibilityChangedEvt_delegate)) {
  75                eventHandlers.AddHandler(VisibilityChangedEvtKey , value);
  76             } else
  77                Eina.Log.Error($"Error adding proxy for event {key}");
  78          }
  79       }
  80       remove {
  81          lock (eventLock) {
  82             string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
  83             if (remove_cpp_event_handler(key, this.evt_VisibilityChangedEvt_delegate)) {
  84                eventHandlers.RemoveHandler(VisibilityChangedEvtKey , value);
  85             } else
  86                Eina.Log.Error($"Error removing proxy for event {key}");
  87          }
  88       }
  89    }
  90    ///<summary>Method to raise event VisibilityChangedEvt.</summary>
  91    public void On_VisibilityChangedEvt(Efl.Gfx.EntityVisibilityChangedEvt_Args e)
  92    {
  93       EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args> evt;
  94       lock (eventLock) {
  95       evt = (EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args>)eventHandlers[VisibilityChangedEvtKey];
  96       }
  97       evt?.Invoke(this, e);
  98    }
  99    Efl.EventCb evt_VisibilityChangedEvt_delegate;
 100    private void on_VisibilityChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 101    {
 102       Efl.Gfx.EntityVisibilityChangedEvt_Args args = new Efl.Gfx.EntityVisibilityChangedEvt_Args();
 103       args.arg = evt.Info != IntPtr.Zero;
 104       try {
 105          On_VisibilityChangedEvt(args);
 106       } catch (Exception e) {
 107          Eina.Log.Error(e.ToString());
 108          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 109       }
 110    }
 111
 112 private static object PositionChangedEvtKey = new object();
 113    /// <summary>Object was moved, its position during the event is the new one.</summary>
 114    public event EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args> PositionChangedEvt
 115    {
 116       add {
 117          lock (eventLock) {
 118             string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 119             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_PositionChangedEvt_delegate)) {
 120                eventHandlers.AddHandler(PositionChangedEvtKey , value);
 121             } else
 122                Eina.Log.Error($"Error adding proxy for event {key}");
 123          }
 124       }
 125       remove {
 126          lock (eventLock) {
 127             string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 128             if (remove_cpp_event_handler(key, this.evt_PositionChangedEvt_delegate)) {
 129                eventHandlers.RemoveHandler(PositionChangedEvtKey , value);
 130             } else
 131                Eina.Log.Error($"Error removing proxy for event {key}");
 132          }
 133       }
 134    }
 135    ///<summary>Method to raise event PositionChangedEvt.</summary>
 136    public void On_PositionChangedEvt(Efl.Gfx.EntityPositionChangedEvt_Args e)
 137    {
 138       EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args> evt;
 139       lock (eventLock) {
 140       evt = (EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args>)eventHandlers[PositionChangedEvtKey];
 141       }
 142       evt?.Invoke(this, e);
 143    }
 144    Efl.EventCb evt_PositionChangedEvt_delegate;
 145    private void on_PositionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 146    {
 147       Efl.Gfx.EntityPositionChangedEvt_Args args = new Efl.Gfx.EntityPositionChangedEvt_Args();
 148       args.arg =  evt.Info;;
 149       try {
 150          On_PositionChangedEvt(args);
 151       } catch (Exception e) {
 152          Eina.Log.Error(e.ToString());
 153          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 154       }
 155    }
 156
 157 private static object SizeChangedEvtKey = new object();
 158    /// <summary>Object was resized, its size during the event is the new one.</summary>
 159    public event EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args> SizeChangedEvt
 160    {
 161       add {
 162          lock (eventLock) {
 163             string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 164             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SizeChangedEvt_delegate)) {
 165                eventHandlers.AddHandler(SizeChangedEvtKey , value);
 166             } else
 167                Eina.Log.Error($"Error adding proxy for event {key}");
 168          }
 169       }
 170       remove {
 171          lock (eventLock) {
 172             string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 173             if (remove_cpp_event_handler(key, this.evt_SizeChangedEvt_delegate)) {
 174                eventHandlers.RemoveHandler(SizeChangedEvtKey , value);
 175             } else
 176                Eina.Log.Error($"Error removing proxy for event {key}");
 177          }
 178       }
 179    }
 180    ///<summary>Method to raise event SizeChangedEvt.</summary>
 181    public void On_SizeChangedEvt(Efl.Gfx.EntitySizeChangedEvt_Args e)
 182    {
 183       EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args> evt;
 184       lock (eventLock) {
 185       evt = (EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args>)eventHandlers[SizeChangedEvtKey];
 186       }
 187       evt?.Invoke(this, e);
 188    }
 189    Efl.EventCb evt_SizeChangedEvt_delegate;
 190    private void on_SizeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 191    {
 192       Efl.Gfx.EntitySizeChangedEvt_Args args = new Efl.Gfx.EntitySizeChangedEvt_Args();
 193       args.arg =  evt.Info;;
 194       try {
 195          On_SizeChangedEvt(args);
 196       } catch (Exception e) {
 197          Eina.Log.Error(e.ToString());
 198          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 199       }
 200    }
 201
 202    protected override void register_event_proxies()
 203    {
 204       base.register_event_proxies();
 205       evt_VisibilityChangedEvt_delegate = new Efl.EventCb(on_VisibilityChangedEvt_NativeCallback);
 206       evt_PositionChangedEvt_delegate = new Efl.EventCb(on_PositionChangedEvt_NativeCallback);
 207       evt_SizeChangedEvt_delegate = new Efl.EventCb(on_SizeChangedEvt_NativeCallback);
 208    }
 209    /// <summary>The name and value of the current state of this part (read-only).
 210    /// 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.
 211    /// 1.20</summary>
 212    /// <param name="state">The name of the state.
 213    /// 1.20</param>
 214    /// <param name="val">The value of the state.
 215    /// 1.20</param>
 216    /// <returns></returns>
 217    virtual public  void GetState( out  System.String state,  out double val) {
 218                                            Efl.Canvas.LayoutPartNativeInherit.efl_canvas_layout_part_state_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out state,  out val);
 219       Eina.Error.RaiseIfUnhandledException();
 220                                }
 221    /// <summary>Returns the type of the part.
 222    /// 1.20</summary>
 223    /// <returns>One of the types or <c>none</c> if not an existing part.
 224    /// 1.20</returns>
 225    virtual public Efl.Canvas.LayoutPartType GetPartType() {
 226        var _ret_var = Efl.Canvas.LayoutPartNativeInherit.efl_canvas_layout_part_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 227       Eina.Error.RaiseIfUnhandledException();
 228       return _ret_var;
 229  }
 230    /// <summary>Retrieves the position of the given canvas object.</summary>
 231    /// <returns>A 2D coordinate in pixel units.</returns>
 232    virtual public Eina.Position2D GetPosition() {
 233        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 234       Eina.Error.RaiseIfUnhandledException();
 235       return Eina.Position2D_StructConversion.ToManaged(_ret_var);
 236  }
 237    /// <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.</summary>
 238    /// <param name="pos">A 2D coordinate in pixel units.</param>
 239    /// <returns></returns>
 240    virtual public  void SetPosition( Eina.Position2D pos) {
 241        var _in_pos = Eina.Position2D_StructConversion.ToInternal(pos);
 242                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_pos);
 243       Eina.Error.RaiseIfUnhandledException();
 244                    }
 245    /// <summary>Retrieves the (rectangular) size of the given Evas object.</summary>
 246    /// <returns>A 2D size in pixel units.</returns>
 247    virtual public Eina.Size2D GetSize() {
 248        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 249       Eina.Error.RaiseIfUnhandledException();
 250       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 251  }
 252    /// <summary>Changes the size of the given object.
 253    /// 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.Hint"/> instead, when manipulating widgets.</summary>
 254    /// <param name="size">A 2D size in pixel units.</param>
 255    /// <returns></returns>
 256    virtual public  void SetSize( Eina.Size2D size) {
 257        var _in_size = Eina.Size2D_StructConversion.ToInternal(size);
 258                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_size);
 259       Eina.Error.RaiseIfUnhandledException();
 260                    }
 261    /// <summary>Rectangular geometry that combines both position and size.</summary>
 262    /// <returns>The X,Y position and W,H size, in pixels.</returns>
 263    virtual public Eina.Rect GetGeometry() {
 264        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 265       Eina.Error.RaiseIfUnhandledException();
 266       return Eina.Rect_StructConversion.ToManaged(_ret_var);
 267  }
 268    /// <summary>Rectangular geometry that combines both position and size.</summary>
 269    /// <param name="rect">The X,Y position and W,H size, in pixels.</param>
 270    /// <returns></returns>
 271    virtual public  void SetGeometry( Eina.Rect rect) {
 272        var _in_rect = Eina.Rect_StructConversion.ToInternal(rect);
 273                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_geometry_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_rect);
 274       Eina.Error.RaiseIfUnhandledException();
 275                    }
 276    /// <summary>Retrieves whether or not the given canvas object is visible.</summary>
 277    /// <returns><c>true</c> if to make the object visible, <c>false</c> otherwise</returns>
 278    virtual public bool GetVisible() {
 279        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_visible_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 280       Eina.Error.RaiseIfUnhandledException();
 281       return _ret_var;
 282  }
 283    /// <summary>Shows or hides this object.</summary>
 284    /// <param name="v"><c>true</c> if to make the object visible, <c>false</c> otherwise</param>
 285    /// <returns></returns>
 286    virtual public  void SetVisible( bool v) {
 287                          Efl.Gfx.EntityNativeInherit.efl_gfx_entity_visible_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), v);
 288       Eina.Error.RaiseIfUnhandledException();
 289                    }
 290    /// <summary>Gets an object&apos;s scaling factor.</summary>
 291    /// <returns>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</returns>
 292    virtual public double GetScale() {
 293        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 294       Eina.Error.RaiseIfUnhandledException();
 295       return _ret_var;
 296  }
 297    /// <summary>Sets the scaling factor of an object.</summary>
 298    /// <param name="scale">The scaling factor (the default value is 0.0, meaning individual scaling is not set)</param>
 299    /// <returns></returns>
 300    virtual public  void SetScale( double scale) {
 301                          Efl.Gfx.EntityNativeInherit.efl_gfx_entity_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), scale);
 302       Eina.Error.RaiseIfUnhandledException();
 303                    }
 304    /// <summary>Gets the draggable object location.
 305    /// 1.20</summary>
 306    /// <param name="dx">The x relative position, from 0 to 1.
 307    /// 1.20</param>
 308    /// <param name="dy">The y relative position, from 0 to 1.
 309    /// 1.20</param>
 310    /// <returns><c>true</c> on success, <c>false</c> otherwise
 311    /// 1.20</returns>
 312    virtual public bool GetDragValue( out double dx,  out double dy) {
 313                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out dx,  out dy);
 314       Eina.Error.RaiseIfUnhandledException();
 315                               return _ret_var;
 316  }
 317    /// <summary>Sets the draggable object location.
 318    /// This places the draggable object at the given location.
 319    /// 1.20</summary>
 320    /// <param name="dx">The x relative position, from 0 to 1.
 321    /// 1.20</param>
 322    /// <param name="dy">The y relative position, from 0 to 1.
 323    /// 1.20</param>
 324    /// <returns><c>true</c> on success, <c>false</c> otherwise
 325    /// 1.20</returns>
 326    virtual public bool SetDragValue( double dx,  double dy) {
 327                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dx,  dy);
 328       Eina.Error.RaiseIfUnhandledException();
 329                               return _ret_var;
 330  }
 331    /// <summary>Gets the size of the dradgable object.
 332    /// 1.20</summary>
 333    /// <param name="dw">The drag relative width, from 0 to 1.
 334    /// 1.20</param>
 335    /// <param name="dh">The drag relative height, from 0 to 1.
 336    /// 1.20</param>
 337    /// <returns><c>true</c> on success, <c>false</c> otherwise
 338    /// 1.20</returns>
 339    virtual public bool GetDragSize( out double dw,  out double dh) {
 340                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out dw,  out dh);
 341       Eina.Error.RaiseIfUnhandledException();
 342                               return _ret_var;
 343  }
 344    /// <summary>Sets the size of the draggable object.
 345    /// 1.20</summary>
 346    /// <param name="dw">The drag relative width, from 0 to 1.
 347    /// 1.20</param>
 348    /// <param name="dh">The drag relative height, from 0 to 1.
 349    /// 1.20</param>
 350    /// <returns><c>true</c> on success, <c>false</c> otherwise
 351    /// 1.20</returns>
 352    virtual public bool SetDragSize( double dw,  double dh) {
 353                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dw,  dh);
 354       Eina.Error.RaiseIfUnhandledException();
 355                               return _ret_var;
 356  }
 357    /// <summary>Gets the draggable direction.
 358    /// 1.20</summary>
 359    /// <returns>The direction(s) premitted for drag.
 360    /// 1.20</returns>
 361    virtual public Efl.Ui.DragDir GetDragDir() {
 362        var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_dir_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 363       Eina.Error.RaiseIfUnhandledException();
 364       return _ret_var;
 365  }
 366    /// <summary>Gets the x and y step increments for the draggable object.
 367    /// 1.20</summary>
 368    /// <param name="dx">The x step relative amount, from 0 to 1.
 369    /// 1.20</param>
 370    /// <param name="dy">The y step relative amount, from 0 to 1.
 371    /// 1.20</param>
 372    /// <returns><c>true</c> on success, <c>false</c> otherwise
 373    /// 1.20</returns>
 374    virtual public bool GetDragStep( out double dx,  out double dy) {
 375                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_step_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out dx,  out dy);
 376       Eina.Error.RaiseIfUnhandledException();
 377                               return _ret_var;
 378  }
 379    /// <summary>Sets the x,y step increments for a draggable object.
 380    /// 1.20</summary>
 381    /// <param name="dx">The x step relative amount, from 0 to 1.
 382    /// 1.20</param>
 383    /// <param name="dy">The y step relative amount, from 0 to 1.
 384    /// 1.20</param>
 385    /// <returns><c>true</c> on success, <c>false</c> otherwise
 386    /// 1.20</returns>
 387    virtual public bool SetDragStep( double dx,  double dy) {
 388                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_step_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dx,  dy);
 389       Eina.Error.RaiseIfUnhandledException();
 390                               return _ret_var;
 391  }
 392    /// <summary>Gets the x,y page step increments for the draggable object.
 393    /// 1.20</summary>
 394    /// <param name="dx">The x page step increment
 395    /// 1.20</param>
 396    /// <param name="dy">The y page step increment
 397    /// 1.20</param>
 398    /// <returns><c>true</c> on success, <c>false</c> otherwise
 399    /// 1.20</returns>
 400    virtual public bool GetDragPage( out double dx,  out double dy) {
 401                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_page_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out dx,  out dy);
 402       Eina.Error.RaiseIfUnhandledException();
 403                               return _ret_var;
 404  }
 405    /// <summary>Sets the x,y page step increment values.
 406    /// 1.20</summary>
 407    /// <param name="dx">The x page step increment
 408    /// 1.20</param>
 409    /// <param name="dy">The y page step increment
 410    /// 1.20</param>
 411    /// <returns><c>true</c> on success, <c>false</c> otherwise
 412    /// 1.20</returns>
 413    virtual public bool SetDragPage( double dx,  double dy) {
 414                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_page_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dx,  dy);
 415       Eina.Error.RaiseIfUnhandledException();
 416                               return _ret_var;
 417  }
 418    /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
 419    /// 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.Drag.GetDragStep"/>.
 420    ///
 421    /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
 422    /// 1.20</summary>
 423    /// <param name="dx">The number of steps horizontally.
 424    /// 1.20</param>
 425    /// <param name="dy">The number of steps vertically.
 426    /// 1.20</param>
 427    /// <returns><c>true</c> on success, <c>false</c> otherwise
 428    /// 1.20</returns>
 429    virtual public bool MoveDragStep( double dx,  double dy) {
 430                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_step_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dx,  dy);
 431       Eina.Error.RaiseIfUnhandledException();
 432                               return _ret_var;
 433  }
 434    /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
 435    /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.Drag.GetDragPage"/>.
 436    ///
 437    /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
 438    ///
 439    /// Warning: Paging is bugged!
 440    /// 1.20</summary>
 441    /// <param name="dx">The number of pages horizontally.
 442    /// 1.20</param>
 443    /// <param name="dy">The number of pages vertically.
 444    /// 1.20</param>
 445    /// <returns><c>true</c> on success, <c>false</c> otherwise
 446    /// 1.20</returns>
 447    virtual public bool MoveDragPage( double dx,  double dy) {
 448                                            var _ret_var = Efl.Ui.DragNativeInherit.efl_ui_drag_page_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dx,  dy);
 449       Eina.Error.RaiseIfUnhandledException();
 450                               return _ret_var;
 451  }
 452    /// <summary>Type of this part in the layout.
 453 /// 1.20</summary>
 454 /// <value>One of the types or <c>none</c> if not an existing part.
 455 /// 1.20</value>
 456    public Efl.Canvas.LayoutPartType PartType {
 457       get { return GetPartType(); }
 458    }
 459    /// <summary>The 2D position of a canvas object.
 460 /// The position is absolute, in pixels, relative to the top-left corner of the window, within its border decorations (application space).</summary>
 461 /// <value>A 2D coordinate in pixel units.</value>
 462    public Eina.Position2D Position {
 463       get { return GetPosition(); }
 464       set { SetPosition( value); }
 465    }
 466    /// <summary>The 2D size of a canvas object.</summary>
 467 /// <value>A 2D size in pixel units.</value>
 468    public Eina.Size2D Size {
 469       get { return GetSize(); }
 470       set { SetSize( value); }
 471    }
 472    /// <summary>Rectangular geometry that combines both position and size.</summary>
 473 /// <value>The X,Y position and W,H size, in pixels.</value>
 474    public Eina.Rect Geometry {
 475       get { return GetGeometry(); }
 476       set { SetGeometry( value); }
 477    }
 478    /// <summary>The visibility of a canvas object.
 479 /// All canvas objects will become visible by default just before render. This means that it is not required to call <see cref="Efl.Gfx.Entity.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.
 480 ///
 481 /// 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...</summary>
 482 /// <value><c>true</c> if to make the object visible, <c>false</c> otherwise</value>
 483    public bool Visible {
 484       get { return GetVisible(); }
 485       set { SetVisible( value); }
 486    }
 487    /// <summary>The scaling factor of an object.
 488 /// 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.
 489 ///
 490 /// 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.</summary>
 491 /// <value>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</value>
 492    public double Scale {
 493       get { return GetScale(); }
 494       set { SetScale( value); }
 495    }
 496    /// <summary>Determines the draggable directions (read-only).
 497 /// 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.
 498 /// 1.20</summary>
 499 /// <value>The direction(s) premitted for drag.
 500 /// 1.20</value>
 501    public Efl.Ui.DragDir DragDir {
 502       get { return GetDragDir(); }
 503    }
 504    private static new  IntPtr GetEflClassStatic()
 505    {
 506       return Efl.Canvas.LayoutPart.efl_canvas_layout_part_class_get();
 507    }
 508 }
 509 public class LayoutPartNativeInherit : Efl.ObjectNativeInherit{
 510    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Edje);
 511    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 512    {
 513       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 514       if (efl_canvas_layout_part_state_get_static_delegate == null)
 515       efl_canvas_layout_part_state_get_static_delegate = new efl_canvas_layout_part_state_get_delegate(state_get);
 516       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)});
 517       if (efl_canvas_layout_part_type_get_static_delegate == null)
 518       efl_canvas_layout_part_type_get_static_delegate = new efl_canvas_layout_part_type_get_delegate(part_type_get);
 519       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)});
 520       if (efl_gfx_entity_position_get_static_delegate == null)
 521       efl_gfx_entity_position_get_static_delegate = new efl_gfx_entity_position_get_delegate(position_get);
 522       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)});
 523       if (efl_gfx_entity_position_set_static_delegate == null)
 524       efl_gfx_entity_position_set_static_delegate = new efl_gfx_entity_position_set_delegate(position_set);
 525       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)});
 526       if (efl_gfx_entity_size_get_static_delegate == null)
 527       efl_gfx_entity_size_get_static_delegate = new efl_gfx_entity_size_get_delegate(size_get);
 528       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)});
 529       if (efl_gfx_entity_size_set_static_delegate == null)
 530       efl_gfx_entity_size_set_static_delegate = new efl_gfx_entity_size_set_delegate(size_set);
 531       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)});
 532       if (efl_gfx_entity_geometry_get_static_delegate == null)
 533       efl_gfx_entity_geometry_get_static_delegate = new efl_gfx_entity_geometry_get_delegate(geometry_get);
 534       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)});
 535       if (efl_gfx_entity_geometry_set_static_delegate == null)
 536       efl_gfx_entity_geometry_set_static_delegate = new efl_gfx_entity_geometry_set_delegate(geometry_set);
 537       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)});
 538       if (efl_gfx_entity_visible_get_static_delegate == null)
 539       efl_gfx_entity_visible_get_static_delegate = new efl_gfx_entity_visible_get_delegate(visible_get);
 540       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)});
 541       if (efl_gfx_entity_visible_set_static_delegate == null)
 542       efl_gfx_entity_visible_set_static_delegate = new efl_gfx_entity_visible_set_delegate(visible_set);
 543       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)});
 544       if (efl_gfx_entity_scale_get_static_delegate == null)
 545       efl_gfx_entity_scale_get_static_delegate = new efl_gfx_entity_scale_get_delegate(scale_get);
 546       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)});
 547       if (efl_gfx_entity_scale_set_static_delegate == null)
 548       efl_gfx_entity_scale_set_static_delegate = new efl_gfx_entity_scale_set_delegate(scale_set);
 549       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)});
 550       if (efl_ui_drag_value_get_static_delegate == null)
 551       efl_ui_drag_value_get_static_delegate = new efl_ui_drag_value_get_delegate(drag_value_get);
 552       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)});
 553       if (efl_ui_drag_value_set_static_delegate == null)
 554       efl_ui_drag_value_set_static_delegate = new efl_ui_drag_value_set_delegate(drag_value_set);
 555       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)});
 556       if (efl_ui_drag_size_get_static_delegate == null)
 557       efl_ui_drag_size_get_static_delegate = new efl_ui_drag_size_get_delegate(drag_size_get);
 558       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)});
 559       if (efl_ui_drag_size_set_static_delegate == null)
 560       efl_ui_drag_size_set_static_delegate = new efl_ui_drag_size_set_delegate(drag_size_set);
 561       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)});
 562       if (efl_ui_drag_dir_get_static_delegate == null)
 563       efl_ui_drag_dir_get_static_delegate = new efl_ui_drag_dir_get_delegate(drag_dir_get);
 564       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)});
 565       if (efl_ui_drag_step_get_static_delegate == null)
 566       efl_ui_drag_step_get_static_delegate = new efl_ui_drag_step_get_delegate(drag_step_get);
 567       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)});
 568       if (efl_ui_drag_step_set_static_delegate == null)
 569       efl_ui_drag_step_set_static_delegate = new efl_ui_drag_step_set_delegate(drag_step_set);
 570       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)});
 571       if (efl_ui_drag_page_get_static_delegate == null)
 572       efl_ui_drag_page_get_static_delegate = new efl_ui_drag_page_get_delegate(drag_page_get);
 573       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)});
 574       if (efl_ui_drag_page_set_static_delegate == null)
 575       efl_ui_drag_page_set_static_delegate = new efl_ui_drag_page_set_delegate(drag_page_set);
 576       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)});
 577       if (efl_ui_drag_step_move_static_delegate == null)
 578       efl_ui_drag_step_move_static_delegate = new efl_ui_drag_step_move_delegate(drag_step_move);
 579       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)});
 580       if (efl_ui_drag_page_move_static_delegate == null)
 581       efl_ui_drag_page_move_static_delegate = new efl_ui_drag_page_move_delegate(drag_page_move);
 582       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)});
 583       descs.AddRange(base.GetEoOps(type));
 584       return descs;
 585    }
 586    public override IntPtr GetEflClass()
 587    {
 588       return Efl.Canvas.LayoutPart.efl_canvas_layout_part_class_get();
 589    }
 590    public static new  IntPtr GetEflClassStatic()
 591    {
 592       return Efl.Canvas.LayoutPart.efl_canvas_layout_part_class_get();
 593    }
 594
 595
 596     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);
 597
 598
 599     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);
 600     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");
 601     private static  void state_get(System.IntPtr obj, System.IntPtr pd,  out  System.String state,  out double val)
 602    {
 603       Eina.Log.Debug("function efl_canvas_layout_part_state_get was called");
 604       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 605       if(wrapper != null) {
 606                             System.String _out_state = default( System.String);
 607       val = default(double);
 608          try {
 609             ((LayoutPart)wrapper).GetState( out _out_state,  out val);
 610          } catch (Exception e) {
 611             Eina.Log.Warning($"Callback error: {e.ToString()}");
 612             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 613          }
 614       state = _out_state;
 615                               } else {
 616          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);
 617       }
 618    }
 619    private static efl_canvas_layout_part_state_get_delegate efl_canvas_layout_part_state_get_static_delegate;
 620
 621
 622     private delegate Efl.Canvas.LayoutPartType efl_canvas_layout_part_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 623
 624
 625     public delegate Efl.Canvas.LayoutPartType efl_canvas_layout_part_type_get_api_delegate(System.IntPtr obj);
 626     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");
 627     private static Efl.Canvas.LayoutPartType part_type_get(System.IntPtr obj, System.IntPtr pd)
 628    {
 629       Eina.Log.Debug("function efl_canvas_layout_part_type_get was called");
 630       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 631       if(wrapper != null) {
 632                   Efl.Canvas.LayoutPartType _ret_var = default(Efl.Canvas.LayoutPartType);
 633          try {
 634             _ret_var = ((LayoutPart)wrapper).GetPartType();
 635          } catch (Exception e) {
 636             Eina.Log.Warning($"Callback error: {e.ToString()}");
 637             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 638          }
 639       return _ret_var;
 640       } else {
 641          return efl_canvas_layout_part_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 642       }
 643    }
 644    private static efl_canvas_layout_part_type_get_delegate efl_canvas_layout_part_type_get_static_delegate;
 645
 646
 647     private delegate Eina.Position2D_StructInternal efl_gfx_entity_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
 648
 649
 650     public delegate Eina.Position2D_StructInternal efl_gfx_entity_position_get_api_delegate(System.IntPtr obj);
 651     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");
 652     private static Eina.Position2D_StructInternal position_get(System.IntPtr obj, System.IntPtr pd)
 653    {
 654       Eina.Log.Debug("function efl_gfx_entity_position_get was called");
 655       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 656       if(wrapper != null) {
 657                   Eina.Position2D _ret_var = default(Eina.Position2D);
 658          try {
 659             _ret_var = ((LayoutPart)wrapper).GetPosition();
 660          } catch (Exception e) {
 661             Eina.Log.Warning($"Callback error: {e.ToString()}");
 662             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 663          }
 664       return Eina.Position2D_StructConversion.ToInternal(_ret_var);
 665       } else {
 666          return efl_gfx_entity_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 667       }
 668    }
 669    private static efl_gfx_entity_position_get_delegate efl_gfx_entity_position_get_static_delegate;
 670
 671
 672     private delegate  void efl_gfx_entity_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D_StructInternal pos);
 673
 674
 675     public delegate  void efl_gfx_entity_position_set_api_delegate(System.IntPtr obj,   Eina.Position2D_StructInternal pos);
 676     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");
 677     private static  void position_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D_StructInternal pos)
 678    {
 679       Eina.Log.Debug("function efl_gfx_entity_position_set was called");
 680       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 681       if(wrapper != null) {
 682                var _in_pos = Eina.Position2D_StructConversion.ToManaged(pos);
 683
 684          try {
 685             ((LayoutPart)wrapper).SetPosition( _in_pos);
 686          } catch (Exception e) {
 687             Eina.Log.Warning($"Callback error: {e.ToString()}");
 688             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 689          }
 690                         } else {
 691          efl_gfx_entity_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pos);
 692       }
 693    }
 694    private static efl_gfx_entity_position_set_delegate efl_gfx_entity_position_set_static_delegate;
 695
 696
 697     private delegate Eina.Size2D_StructInternal efl_gfx_entity_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 698
 699
 700     public delegate Eina.Size2D_StructInternal efl_gfx_entity_size_get_api_delegate(System.IntPtr obj);
 701     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");
 702     private static Eina.Size2D_StructInternal size_get(System.IntPtr obj, System.IntPtr pd)
 703    {
 704       Eina.Log.Debug("function efl_gfx_entity_size_get was called");
 705       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 706       if(wrapper != null) {
 707                   Eina.Size2D _ret_var = default(Eina.Size2D);
 708          try {
 709             _ret_var = ((LayoutPart)wrapper).GetSize();
 710          } catch (Exception e) {
 711             Eina.Log.Warning($"Callback error: {e.ToString()}");
 712             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 713          }
 714       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 715       } else {
 716          return efl_gfx_entity_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 717       }
 718    }
 719    private static efl_gfx_entity_size_get_delegate efl_gfx_entity_size_get_static_delegate;
 720
 721
 722     private delegate  void efl_gfx_entity_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal size);
 723
 724
 725     public delegate  void efl_gfx_entity_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal size);
 726     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");
 727     private static  void size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal size)
 728    {
 729       Eina.Log.Debug("function efl_gfx_entity_size_set was called");
 730       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 731       if(wrapper != null) {
 732                var _in_size = Eina.Size2D_StructConversion.ToManaged(size);
 733
 734          try {
 735             ((LayoutPart)wrapper).SetSize( _in_size);
 736          } catch (Exception e) {
 737             Eina.Log.Warning($"Callback error: {e.ToString()}");
 738             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 739          }
 740                         } else {
 741          efl_gfx_entity_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
 742       }
 743    }
 744    private static efl_gfx_entity_size_set_delegate efl_gfx_entity_size_set_static_delegate;
 745
 746
 747     private delegate Eina.Rect_StructInternal efl_gfx_entity_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
 748
 749
 750     public delegate Eina.Rect_StructInternal efl_gfx_entity_geometry_get_api_delegate(System.IntPtr obj);
 751     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");
 752     private static Eina.Rect_StructInternal geometry_get(System.IntPtr obj, System.IntPtr pd)
 753    {
 754       Eina.Log.Debug("function efl_gfx_entity_geometry_get was called");
 755       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 756       if(wrapper != null) {
 757                   Eina.Rect _ret_var = default(Eina.Rect);
 758          try {
 759             _ret_var = ((LayoutPart)wrapper).GetGeometry();
 760          } catch (Exception e) {
 761             Eina.Log.Warning($"Callback error: {e.ToString()}");
 762             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 763          }
 764       return Eina.Rect_StructConversion.ToInternal(_ret_var);
 765       } else {
 766          return efl_gfx_entity_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 767       }
 768    }
 769    private static efl_gfx_entity_geometry_get_delegate efl_gfx_entity_geometry_get_static_delegate;
 770
 771
 772     private delegate  void efl_gfx_entity_geometry_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect_StructInternal rect);
 773
 774
 775     public delegate  void efl_gfx_entity_geometry_set_api_delegate(System.IntPtr obj,   Eina.Rect_StructInternal rect);
 776     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");
 777     private static  void geometry_set(System.IntPtr obj, System.IntPtr pd,  Eina.Rect_StructInternal rect)
 778    {
 779       Eina.Log.Debug("function efl_gfx_entity_geometry_set was called");
 780       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 781       if(wrapper != null) {
 782                var _in_rect = Eina.Rect_StructConversion.ToManaged(rect);
 783
 784          try {
 785             ((LayoutPart)wrapper).SetGeometry( _in_rect);
 786          } catch (Exception e) {
 787             Eina.Log.Warning($"Callback error: {e.ToString()}");
 788             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 789          }
 790                         } else {
 791          efl_gfx_entity_geometry_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  rect);
 792       }
 793    }
 794    private static efl_gfx_entity_geometry_set_delegate efl_gfx_entity_geometry_set_static_delegate;
 795
 796
 797     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_entity_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
 798
 799
 800     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_entity_visible_get_api_delegate(System.IntPtr obj);
 801     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");
 802     private static bool visible_get(System.IntPtr obj, System.IntPtr pd)
 803    {
 804       Eina.Log.Debug("function efl_gfx_entity_visible_get was called");
 805       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 806       if(wrapper != null) {
 807                   bool _ret_var = default(bool);
 808          try {
 809             _ret_var = ((LayoutPart)wrapper).GetVisible();
 810          } catch (Exception e) {
 811             Eina.Log.Warning($"Callback error: {e.ToString()}");
 812             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 813          }
 814       return _ret_var;
 815       } else {
 816          return efl_gfx_entity_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 817       }
 818    }
 819    private static efl_gfx_entity_visible_get_delegate efl_gfx_entity_visible_get_static_delegate;
 820
 821
 822     private delegate  void efl_gfx_entity_visible_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool v);
 823
 824
 825     public delegate  void efl_gfx_entity_visible_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool v);
 826     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");
 827     private static  void visible_set(System.IntPtr obj, System.IntPtr pd,  bool v)
 828    {
 829       Eina.Log.Debug("function efl_gfx_entity_visible_set was called");
 830       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 831       if(wrapper != null) {
 832
 833          try {
 834             ((LayoutPart)wrapper).SetVisible( v);
 835          } catch (Exception e) {
 836             Eina.Log.Warning($"Callback error: {e.ToString()}");
 837             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 838          }
 839                         } else {
 840          efl_gfx_entity_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  v);
 841       }
 842    }
 843    private static efl_gfx_entity_visible_set_delegate efl_gfx_entity_visible_set_static_delegate;
 844
 845
 846     private delegate double efl_gfx_entity_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
 847
 848
 849     public delegate double efl_gfx_entity_scale_get_api_delegate(System.IntPtr obj);
 850     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");
 851     private static double scale_get(System.IntPtr obj, System.IntPtr pd)
 852    {
 853       Eina.Log.Debug("function efl_gfx_entity_scale_get was called");
 854       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 855       if(wrapper != null) {
 856                   double _ret_var = default(double);
 857          try {
 858             _ret_var = ((LayoutPart)wrapper).GetScale();
 859          } catch (Exception e) {
 860             Eina.Log.Warning($"Callback error: {e.ToString()}");
 861             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 862          }
 863       return _ret_var;
 864       } else {
 865          return efl_gfx_entity_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 866       }
 867    }
 868    private static efl_gfx_entity_scale_get_delegate efl_gfx_entity_scale_get_static_delegate;
 869
 870
 871     private delegate  void efl_gfx_entity_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,   double scale);
 872
 873
 874     public delegate  void efl_gfx_entity_scale_set_api_delegate(System.IntPtr obj,   double scale);
 875     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");
 876     private static  void scale_set(System.IntPtr obj, System.IntPtr pd,  double scale)
 877    {
 878       Eina.Log.Debug("function efl_gfx_entity_scale_set was called");
 879       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 880       if(wrapper != null) {
 881
 882          try {
 883             ((LayoutPart)wrapper).SetScale( scale);
 884          } catch (Exception e) {
 885             Eina.Log.Warning($"Callback error: {e.ToString()}");
 886             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 887          }
 888                         } else {
 889          efl_gfx_entity_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scale);
 890       }
 891    }
 892    private static efl_gfx_entity_scale_set_delegate efl_gfx_entity_scale_set_static_delegate;
 893
 894
 895     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_value_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
 896
 897
 898     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_value_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
 899     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");
 900     private static bool drag_value_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
 901    {
 902       Eina.Log.Debug("function efl_ui_drag_value_get was called");
 903       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 904       if(wrapper != null) {
 905                            dx = default(double);      dy = default(double);                     bool _ret_var = default(bool);
 906          try {
 907             _ret_var = ((LayoutPart)wrapper).GetDragValue( out dx,  out dy);
 908          } catch (Exception e) {
 909             Eina.Log.Warning($"Callback error: {e.ToString()}");
 910             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 911          }
 912                               return _ret_var;
 913       } else {
 914          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);
 915       }
 916    }
 917    private static efl_ui_drag_value_get_delegate efl_ui_drag_value_get_static_delegate;
 918
 919
 920     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_value_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 921
 922
 923     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_value_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
 924     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");
 925     private static bool drag_value_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 926    {
 927       Eina.Log.Debug("function efl_ui_drag_value_set was called");
 928       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 929       if(wrapper != null) {
 930                                                       bool _ret_var = default(bool);
 931          try {
 932             _ret_var = ((LayoutPart)wrapper).SetDragValue( dx,  dy);
 933          } catch (Exception e) {
 934             Eina.Log.Warning($"Callback error: {e.ToString()}");
 935             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 936          }
 937                               return _ret_var;
 938       } else {
 939          return efl_ui_drag_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 940       }
 941    }
 942    private static efl_ui_drag_value_set_delegate efl_ui_drag_value_set_static_delegate;
 943
 944
 945     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_size_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dw,   out double dh);
 946
 947
 948     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_size_get_api_delegate(System.IntPtr obj,   out double dw,   out double dh);
 949     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");
 950     private static bool drag_size_get(System.IntPtr obj, System.IntPtr pd,  out double dw,  out double dh)
 951    {
 952       Eina.Log.Debug("function efl_ui_drag_size_get was called");
 953       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 954       if(wrapper != null) {
 955                            dw = default(double);      dh = default(double);                     bool _ret_var = default(bool);
 956          try {
 957             _ret_var = ((LayoutPart)wrapper).GetDragSize( out dw,  out dh);
 958          } catch (Exception e) {
 959             Eina.Log.Warning($"Callback error: {e.ToString()}");
 960             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 961          }
 962                               return _ret_var;
 963       } else {
 964          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);
 965       }
 966    }
 967    private static efl_ui_drag_size_get_delegate efl_ui_drag_size_get_static_delegate;
 968
 969
 970     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dw,   double dh);
 971
 972
 973     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_size_set_api_delegate(System.IntPtr obj,   double dw,   double dh);
 974     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");
 975     private static bool drag_size_set(System.IntPtr obj, System.IntPtr pd,  double dw,  double dh)
 976    {
 977       Eina.Log.Debug("function efl_ui_drag_size_set was called");
 978       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 979       if(wrapper != null) {
 980                                                       bool _ret_var = default(bool);
 981          try {
 982             _ret_var = ((LayoutPart)wrapper).SetDragSize( dw,  dh);
 983          } catch (Exception e) {
 984             Eina.Log.Warning($"Callback error: {e.ToString()}");
 985             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 986          }
 987                               return _ret_var;
 988       } else {
 989          return efl_ui_drag_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dw,  dh);
 990       }
 991    }
 992    private static efl_ui_drag_size_set_delegate efl_ui_drag_size_set_static_delegate;
 993
 994
 995     private delegate Efl.Ui.DragDir efl_ui_drag_dir_get_delegate(System.IntPtr obj, System.IntPtr pd);
 996
 997
 998     public delegate Efl.Ui.DragDir efl_ui_drag_dir_get_api_delegate(System.IntPtr obj);
 999     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");
1000     private static Efl.Ui.DragDir drag_dir_get(System.IntPtr obj, System.IntPtr pd)
1001    {
1002       Eina.Log.Debug("function efl_ui_drag_dir_get was called");
1003       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1004       if(wrapper != null) {
1005                   Efl.Ui.DragDir _ret_var = default(Efl.Ui.DragDir);
1006          try {
1007             _ret_var = ((LayoutPart)wrapper).GetDragDir();
1008          } catch (Exception e) {
1009             Eina.Log.Warning($"Callback error: {e.ToString()}");
1010             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1011          }
1012       return _ret_var;
1013       } else {
1014          return efl_ui_drag_dir_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1015       }
1016    }
1017    private static efl_ui_drag_dir_get_delegate efl_ui_drag_dir_get_static_delegate;
1018
1019
1020     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
1021
1022
1023     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
1024     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");
1025     private static bool drag_step_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
1026    {
1027       Eina.Log.Debug("function efl_ui_drag_step_get was called");
1028       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1029       if(wrapper != null) {
1030                            dx = default(double);      dy = default(double);                     bool _ret_var = default(bool);
1031          try {
1032             _ret_var = ((LayoutPart)wrapper).GetDragStep( out dx,  out dy);
1033          } catch (Exception e) {
1034             Eina.Log.Warning($"Callback error: {e.ToString()}");
1035             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1036          }
1037                               return _ret_var;
1038       } else {
1039          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);
1040       }
1041    }
1042    private static efl_ui_drag_step_get_delegate efl_ui_drag_step_get_static_delegate;
1043
1044
1045     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
1046
1047
1048     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
1049     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");
1050     private static bool drag_step_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
1051    {
1052       Eina.Log.Debug("function efl_ui_drag_step_set was called");
1053       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1054       if(wrapper != null) {
1055                                                       bool _ret_var = default(bool);
1056          try {
1057             _ret_var = ((LayoutPart)wrapper).SetDragStep( dx,  dy);
1058          } catch (Exception e) {
1059             Eina.Log.Warning($"Callback error: {e.ToString()}");
1060             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1061          }
1062                               return _ret_var;
1063       } else {
1064          return efl_ui_drag_step_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
1065       }
1066    }
1067    private static efl_ui_drag_step_set_delegate efl_ui_drag_step_set_static_delegate;
1068
1069
1070     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
1071
1072
1073     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
1074     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");
1075     private static bool drag_page_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
1076    {
1077       Eina.Log.Debug("function efl_ui_drag_page_get was called");
1078       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1079       if(wrapper != null) {
1080                            dx = default(double);      dy = default(double);                     bool _ret_var = default(bool);
1081          try {
1082             _ret_var = ((LayoutPart)wrapper).GetDragPage( out dx,  out dy);
1083          } catch (Exception e) {
1084             Eina.Log.Warning($"Callback error: {e.ToString()}");
1085             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1086          }
1087                               return _ret_var;
1088       } else {
1089          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);
1090       }
1091    }
1092    private static efl_ui_drag_page_get_delegate efl_ui_drag_page_get_static_delegate;
1093
1094
1095     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
1096
1097
1098     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
1099     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");
1100     private static bool drag_page_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
1101    {
1102       Eina.Log.Debug("function efl_ui_drag_page_set was called");
1103       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1104       if(wrapper != null) {
1105                                                       bool _ret_var = default(bool);
1106          try {
1107             _ret_var = ((LayoutPart)wrapper).SetDragPage( dx,  dy);
1108          } catch (Exception e) {
1109             Eina.Log.Warning($"Callback error: {e.ToString()}");
1110             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1111          }
1112                               return _ret_var;
1113       } else {
1114          return efl_ui_drag_page_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
1115       }
1116    }
1117    private static efl_ui_drag_page_set_delegate efl_ui_drag_page_set_static_delegate;
1118
1119
1120     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_move_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
1121
1122
1123     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_move_api_delegate(System.IntPtr obj,   double dx,   double dy);
1124     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");
1125     private static bool drag_step_move(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
1126    {
1127       Eina.Log.Debug("function efl_ui_drag_step_move was called");
1128       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1129       if(wrapper != null) {
1130                                                       bool _ret_var = default(bool);
1131          try {
1132             _ret_var = ((LayoutPart)wrapper).MoveDragStep( dx,  dy);
1133          } catch (Exception e) {
1134             Eina.Log.Warning($"Callback error: {e.ToString()}");
1135             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1136          }
1137                               return _ret_var;
1138       } else {
1139          return efl_ui_drag_step_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
1140       }
1141    }
1142    private static efl_ui_drag_step_move_delegate efl_ui_drag_step_move_static_delegate;
1143
1144
1145     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_move_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
1146
1147
1148     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_move_api_delegate(System.IntPtr obj,   double dx,   double dy);
1149     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");
1150     private static bool drag_page_move(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
1151    {
1152       Eina.Log.Debug("function efl_ui_drag_page_move was called");
1153       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1154       if(wrapper != null) {
1155                                                       bool _ret_var = default(bool);
1156          try {
1157             _ret_var = ((LayoutPart)wrapper).MoveDragPage( dx,  dy);
1158          } catch (Exception e) {
1159             Eina.Log.Warning($"Callback error: {e.ToString()}");
1160             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1161          }
1162                               return _ret_var;
1163       } else {
1164          return efl_ui_drag_page_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
1165       }
1166    }
1167    private static efl_ui_drag_page_move_delegate efl_ui_drag_page_move_static_delegate;
1168 }
1169 } }