internals/src/EflSharp/EflSharp/efl/efl_canvas_vg_node.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 { namespace Vg {
   8 /// <summary>Efl vector graphics abstract class</summary>
   9 [NodeNativeInherit]
  10 public abstract class Node : Efl.Object, Efl.Eo.IWrapper,Efl.IDuplicate,Efl.Gfx.IColor,Efl.Gfx.IEntity,Efl.Gfx.IPath,Efl.Gfx.IStack
  11 {
  12     ///<summary>Pointer to the native class description.</summary>
  13     public override System.IntPtr NativeClass {
  14         get {
  15             if (((object)this).GetType() == typeof (Node))
  16                 return Efl.Canvas.Vg.NodeNativeInherit.GetEflClassStatic();
  17             else
  18                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  19         }
  20     }
  21     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  22         efl_canvas_vg_node_class_get();
  23     ///<summary>Creates a new instance.</summary>
  24     ///<param name="parent">Parent instance.</param>
  25     public Node(Efl.Object parent= null
  26             ) :
  27         base(efl_canvas_vg_node_class_get(), typeof(Node), parent)
  28     {
  29         FinishInstantiation();
  30     }
  31     ///<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>
  32     protected Node(System.IntPtr raw) : base(raw)
  33     {
  34                 RegisterEventProxies();
  35     }
  36     [Efl.Eo.PrivateNativeClass]
  37     private class NodeRealized : Node
  38     {
  39         private NodeRealized(IntPtr ptr) : base(ptr)
  40         {
  41         }
  42     }
  43     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  44     protected Node(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  45     ///<summary>Verifies if the given object is equal to this one.</summary>
  46     public override bool Equals(object obj)
  47     {
  48         var other = obj as Efl.Object;
  49         if (other == null)
  50             return false;
  51         return this.NativeHandle == other.NativeHandle;
  52     }
  53     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  54     public override int GetHashCode()
  55     {
  56         return this.NativeHandle.ToInt32();
  57     }
  58     ///<summary>Turns the native pointer into a string representation.</summary>
  59     public override String ToString()
  60     {
  61         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  62     }
  63 private static object VisibilityChangedEvtKey = new object();
  64     /// <summary>Object&apos;s visibility state changed, the event value is the new state.
  65     /// (Since EFL 1.22)</summary>
  66     public event EventHandler<Efl.Gfx.IEntityVisibilityChangedEvt_Args> VisibilityChangedEvt
  67     {
  68         add {
  69             lock (eventLock) {
  70                 string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
  71                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_VisibilityChangedEvt_delegate)) {
  72                     eventHandlers.AddHandler(VisibilityChangedEvtKey , value);
  73                 } else
  74                     Eina.Log.Error($"Error adding proxy for event {key}");
  75             }
  76         }
  77         remove {
  78             lock (eventLock) {
  79                 string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
  80                 if (RemoveNativeEventHandler(key, this.evt_VisibilityChangedEvt_delegate)) {
  81                     eventHandlers.RemoveHandler(VisibilityChangedEvtKey , value);
  82                 } else
  83                     Eina.Log.Error($"Error removing proxy for event {key}");
  84             }
  85         }
  86     }
  87     ///<summary>Method to raise event VisibilityChangedEvt.</summary>
  88     public void On_VisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
  89     {
  90         EventHandler<Efl.Gfx.IEntityVisibilityChangedEvt_Args> evt;
  91         lock (eventLock) {
  92         evt = (EventHandler<Efl.Gfx.IEntityVisibilityChangedEvt_Args>)eventHandlers[VisibilityChangedEvtKey];
  93         }
  94         evt?.Invoke(this, e);
  95     }
  96     Efl.EventCb evt_VisibilityChangedEvt_delegate;
  97     private void on_VisibilityChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  98     {
  99         Efl.Gfx.IEntityVisibilityChangedEvt_Args args = new Efl.Gfx.IEntityVisibilityChangedEvt_Args();
 100       args.arg = evt.Info != IntPtr.Zero;
 101         try {
 102             On_VisibilityChangedEvt(args);
 103         } catch (Exception e) {
 104             Eina.Log.Error(e.ToString());
 105             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 106         }
 107     }
 108
 109 private static object PositionChangedEvtKey = new object();
 110     /// <summary>Object was moved, its position during the event is the new one.
 111     /// (Since EFL 1.22)</summary>
 112     public event EventHandler<Efl.Gfx.IEntityPositionChangedEvt_Args> PositionChangedEvt
 113     {
 114         add {
 115             lock (eventLock) {
 116                 string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 117                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_PositionChangedEvt_delegate)) {
 118                     eventHandlers.AddHandler(PositionChangedEvtKey , value);
 119                 } else
 120                     Eina.Log.Error($"Error adding proxy for event {key}");
 121             }
 122         }
 123         remove {
 124             lock (eventLock) {
 125                 string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 126                 if (RemoveNativeEventHandler(key, this.evt_PositionChangedEvt_delegate)) {
 127                     eventHandlers.RemoveHandler(PositionChangedEvtKey , value);
 128                 } else
 129                     Eina.Log.Error($"Error removing proxy for event {key}");
 130             }
 131         }
 132     }
 133     ///<summary>Method to raise event PositionChangedEvt.</summary>
 134     public void On_PositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
 135     {
 136         EventHandler<Efl.Gfx.IEntityPositionChangedEvt_Args> evt;
 137         lock (eventLock) {
 138         evt = (EventHandler<Efl.Gfx.IEntityPositionChangedEvt_Args>)eventHandlers[PositionChangedEvtKey];
 139         }
 140         evt?.Invoke(this, e);
 141     }
 142     Efl.EventCb evt_PositionChangedEvt_delegate;
 143     private void on_PositionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 144     {
 145         Efl.Gfx.IEntityPositionChangedEvt_Args args = new Efl.Gfx.IEntityPositionChangedEvt_Args();
 146       args.arg =  evt.Info;;
 147         try {
 148             On_PositionChangedEvt(args);
 149         } catch (Exception e) {
 150             Eina.Log.Error(e.ToString());
 151             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 152         }
 153     }
 154
 155 private static object SizeChangedEvtKey = new object();
 156     /// <summary>Object was resized, its size during the event is the new one.
 157     /// (Since EFL 1.22)</summary>
 158     public event EventHandler<Efl.Gfx.IEntitySizeChangedEvt_Args> SizeChangedEvt
 159     {
 160         add {
 161             lock (eventLock) {
 162                 string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 163                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_SizeChangedEvt_delegate)) {
 164                     eventHandlers.AddHandler(SizeChangedEvtKey , value);
 165                 } else
 166                     Eina.Log.Error($"Error adding proxy for event {key}");
 167             }
 168         }
 169         remove {
 170             lock (eventLock) {
 171                 string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 172                 if (RemoveNativeEventHandler(key, this.evt_SizeChangedEvt_delegate)) {
 173                     eventHandlers.RemoveHandler(SizeChangedEvtKey , value);
 174                 } else
 175                     Eina.Log.Error($"Error removing proxy for event {key}");
 176             }
 177         }
 178     }
 179     ///<summary>Method to raise event SizeChangedEvt.</summary>
 180     public void On_SizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
 181     {
 182         EventHandler<Efl.Gfx.IEntitySizeChangedEvt_Args> evt;
 183         lock (eventLock) {
 184         evt = (EventHandler<Efl.Gfx.IEntitySizeChangedEvt_Args>)eventHandlers[SizeChangedEvtKey];
 185         }
 186         evt?.Invoke(this, e);
 187     }
 188     Efl.EventCb evt_SizeChangedEvt_delegate;
 189     private void on_SizeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 190     {
 191         Efl.Gfx.IEntitySizeChangedEvt_Args args = new Efl.Gfx.IEntitySizeChangedEvt_Args();
 192       args.arg =  evt.Info;;
 193         try {
 194             On_SizeChangedEvt(args);
 195         } catch (Exception e) {
 196             Eina.Log.Error(e.ToString());
 197             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 198         }
 199     }
 200
 201 private static object StackingChangedEvtKey = new object();
 202     /// <summary>Object stacking was changed.
 203     /// (Since EFL 1.22)</summary>
 204     public event EventHandler StackingChangedEvt
 205     {
 206         add {
 207             lock (eventLock) {
 208                 string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
 209                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_StackingChangedEvt_delegate)) {
 210                     eventHandlers.AddHandler(StackingChangedEvtKey , value);
 211                 } else
 212                     Eina.Log.Error($"Error adding proxy for event {key}");
 213             }
 214         }
 215         remove {
 216             lock (eventLock) {
 217                 string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
 218                 if (RemoveNativeEventHandler(key, this.evt_StackingChangedEvt_delegate)) {
 219                     eventHandlers.RemoveHandler(StackingChangedEvtKey , value);
 220                 } else
 221                     Eina.Log.Error($"Error removing proxy for event {key}");
 222             }
 223         }
 224     }
 225     ///<summary>Method to raise event StackingChangedEvt.</summary>
 226     public void On_StackingChangedEvt(EventArgs e)
 227     {
 228         EventHandler evt;
 229         lock (eventLock) {
 230         evt = (EventHandler)eventHandlers[StackingChangedEvtKey];
 231         }
 232         evt?.Invoke(this, e);
 233     }
 234     Efl.EventCb evt_StackingChangedEvt_delegate;
 235     private void on_StackingChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 236     {
 237         EventArgs args = EventArgs.Empty;
 238         try {
 239             On_StackingChangedEvt(args);
 240         } catch (Exception e) {
 241             Eina.Log.Error(e.ToString());
 242             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 243         }
 244     }
 245
 246     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 247     protected override void RegisterEventProxies()
 248     {
 249         base.RegisterEventProxies();
 250         evt_VisibilityChangedEvt_delegate = new Efl.EventCb(on_VisibilityChangedEvt_NativeCallback);
 251         evt_PositionChangedEvt_delegate = new Efl.EventCb(on_PositionChangedEvt_NativeCallback);
 252         evt_SizeChangedEvt_delegate = new Efl.EventCb(on_SizeChangedEvt_NativeCallback);
 253         evt_StackingChangedEvt_delegate = new Efl.EventCb(on_StackingChangedEvt_NativeCallback);
 254     }
 255     /// <summary>Gets the transformation matrix used for this node object.</summary>
 256     /// <returns>Transformation matrix.</returns>
 257     virtual public Eina.Matrix3 GetTransformation() {
 258          var _ret_var = Efl.Canvas.Vg.NodeNativeInherit.efl_canvas_vg_node_transformation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 259         Eina.Error.RaiseIfUnhandledException();
 260         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Eina.Matrix3>(_ret_var);
 261
 262         return __ret_tmp;
 263  }
 264     /// <summary>Sets the transformation matrix to be used for this node object.
 265     /// Note: Pass <c>null</c> to cancel the applied transformation.</summary>
 266     /// <param name="m">Transformation matrix.</param>
 267     /// <returns></returns>
 268     virtual public void SetTransformation( ref Eina.Matrix3 m) {
 269          Eina.Matrix3.NativeStruct _in_m = m;
 270                         Efl.Canvas.Vg.NodeNativeInherit.efl_canvas_vg_node_transformation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ref _in_m);
 271         Eina.Error.RaiseIfUnhandledException();
 272                 m = _in_m;
 273          }
 274     /// <summary>Gets the origin position of the node object.</summary>
 275     /// <param name="x"><c>origin</c> x position.</param>
 276     /// <param name="y"><c>origin</c> y position.</param>
 277     /// <returns></returns>
 278     virtual public void GetOrigin( out double x,  out double y) {
 279                                                          Efl.Canvas.Vg.NodeNativeInherit.efl_canvas_vg_node_origin_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
 280         Eina.Error.RaiseIfUnhandledException();
 281                                          }
 282     /// <summary>Sets the origin position of the node object.
 283     /// This origin position affects node transformation.</summary>
 284     /// <param name="x"><c>origin</c> x position.</param>
 285     /// <param name="y"><c>origin</c> y position.</param>
 286     /// <returns></returns>
 287     virtual public void SetOrigin( double x,  double y) {
 288                                                          Efl.Canvas.Vg.NodeNativeInherit.efl_canvas_vg_node_origin_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
 289         Eina.Error.RaiseIfUnhandledException();
 290                                          }
 291     /// <summary>Set Mask Node to this renderer</summary>
 292     /// <param name="mask">Mask object</param>
 293     /// <param name="op">Masking Option. Reserved</param>
 294     /// <returns></returns>
 295     virtual public void SetMask( Efl.Canvas.Vg.Node mask,  int op) {
 296                                                          Efl.Canvas.Vg.NodeNativeInherit.efl_canvas_vg_node_mask_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), mask,  op);
 297         Eina.Error.RaiseIfUnhandledException();
 298                                          }
 299     /// <summary>Creates a carbon copy of this object and returns it.
 300     /// The newly created object will have no event handlers or anything of the sort.</summary>
 301     /// <returns>Returned carbon copy</returns>
 302     virtual public Efl.IDuplicate DoDuplicate() {
 303          var _ret_var = Efl.IDuplicateNativeInherit.efl_duplicate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 304         Eina.Error.RaiseIfUnhandledException();
 305         return _ret_var;
 306  }
 307     /// <summary>Retrieves the general/main color of the given Evas object.
 308     /// Retrieves the main color&apos;s RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object&apos;s transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
 309     ///
 310     /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
 311     ///
 312     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 313     ///
 314     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 315     /// (Since EFL 1.22)</summary>
 316     /// <param name="r"></param>
 317     /// <param name="g"></param>
 318     /// <param name="b"></param>
 319     /// <param name="a"></param>
 320     /// <returns></returns>
 321     virtual public void GetColor( out int r,  out int g,  out int b,  out int a) {
 322                                                                                                          Efl.Gfx.IColorNativeInherit.efl_gfx_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out r,  out g,  out b,  out a);
 323         Eina.Error.RaiseIfUnhandledException();
 324                                                                          }
 325     /// <summary>Sets the general/main color of the given Evas object to the given one.
 326     /// See also <see cref="Efl.Gfx.IColor.GetColor"/> (for an example)
 327     ///
 328     /// These color values are expected to be premultiplied by alpha.
 329     /// (Since EFL 1.22)</summary>
 330     /// <param name="r"></param>
 331     /// <param name="g"></param>
 332     /// <param name="b"></param>
 333     /// <param name="a"></param>
 334     /// <returns></returns>
 335     virtual public void SetColor( int r,  int g,  int b,  int a) {
 336                                                                                                          Efl.Gfx.IColorNativeInherit.efl_gfx_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), r,  g,  b,  a);
 337         Eina.Error.RaiseIfUnhandledException();
 338                                                                          }
 339     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 340     /// (Since EFL 1.22)</summary>
 341     /// <returns>the hex color code.</returns>
 342     virtual public System.String GetColorCode() {
 343          var _ret_var = Efl.Gfx.IColorNativeInherit.efl_gfx_color_code_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 344         Eina.Error.RaiseIfUnhandledException();
 345         return _ret_var;
 346  }
 347     /// <summary>Set the color of given Evas object to the given hex color code(#RRGGBBAA). e.g. efl_gfx_color_code_set(obj, &quot;#FFCCAACC&quot;);
 348     /// (Since EFL 1.22)</summary>
 349     /// <param name="colorcode">the hex color code.</param>
 350     /// <returns></returns>
 351     virtual public void SetColorCode( System.String colorcode) {
 352                                  Efl.Gfx.IColorNativeInherit.efl_gfx_color_code_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), colorcode);
 353         Eina.Error.RaiseIfUnhandledException();
 354                          }
 355     /// <summary>Retrieves the position of the given canvas object.
 356     /// (Since EFL 1.22)</summary>
 357     /// <returns>A 2D coordinate in pixel units.</returns>
 358     virtual public Eina.Position2D GetPosition() {
 359          var _ret_var = Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 360         Eina.Error.RaiseIfUnhandledException();
 361         return _ret_var;
 362  }
 363     /// <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.
 364     /// (Since EFL 1.22)</summary>
 365     /// <param name="pos">A 2D coordinate in pixel units.</param>
 366     /// <returns></returns>
 367     virtual public void SetPosition( Eina.Position2D pos) {
 368          Eina.Position2D.NativeStruct _in_pos = pos;
 369                         Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_pos);
 370         Eina.Error.RaiseIfUnhandledException();
 371                          }
 372     /// <summary>Retrieves the (rectangular) size of the given Evas object.
 373     /// (Since EFL 1.22)</summary>
 374     /// <returns>A 2D size in pixel units.</returns>
 375     virtual public Eina.Size2D GetSize() {
 376          var _ret_var = Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 377         Eina.Error.RaiseIfUnhandledException();
 378         return _ret_var;
 379  }
 380     /// <summary>Changes the size of the given object.
 381     /// 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.
 382     /// (Since EFL 1.22)</summary>
 383     /// <param name="size">A 2D size in pixel units.</param>
 384     /// <returns></returns>
 385     virtual public void SetSize( Eina.Size2D size) {
 386          Eina.Size2D.NativeStruct _in_size = size;
 387                         Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_size);
 388         Eina.Error.RaiseIfUnhandledException();
 389                          }
 390     /// <summary>Rectangular geometry that combines both position and size.
 391     /// (Since EFL 1.22)</summary>
 392     /// <returns>The X,Y position and W,H size, in pixels.</returns>
 393     virtual public Eina.Rect GetGeometry() {
 394          var _ret_var = Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 395         Eina.Error.RaiseIfUnhandledException();
 396         return _ret_var;
 397  }
 398     /// <summary>Rectangular geometry that combines both position and size.
 399     /// (Since EFL 1.22)</summary>
 400     /// <param name="rect">The X,Y position and W,H size, in pixels.</param>
 401     /// <returns></returns>
 402     virtual public void SetGeometry( Eina.Rect rect) {
 403          Eina.Rect.NativeStruct _in_rect = rect;
 404                         Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_geometry_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_rect);
 405         Eina.Error.RaiseIfUnhandledException();
 406                          }
 407     /// <summary>Retrieves whether or not the given canvas object is visible.
 408     /// (Since EFL 1.22)</summary>
 409     /// <returns><c>true</c> if to make the object visible, <c>false</c> otherwise</returns>
 410     virtual public bool GetVisible() {
 411          var _ret_var = Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_visible_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 412         Eina.Error.RaiseIfUnhandledException();
 413         return _ret_var;
 414  }
 415     /// <summary>Shows or hides this object.
 416     /// (Since EFL 1.22)</summary>
 417     /// <param name="v"><c>true</c> if to make the object visible, <c>false</c> otherwise</param>
 418     /// <returns></returns>
 419     virtual public void SetVisible( bool v) {
 420                                  Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_visible_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), v);
 421         Eina.Error.RaiseIfUnhandledException();
 422                          }
 423     /// <summary>Gets an object&apos;s scaling factor.
 424     /// (Since EFL 1.22)</summary>
 425     /// <returns>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</returns>
 426     virtual public double GetScale() {
 427          var _ret_var = Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 428         Eina.Error.RaiseIfUnhandledException();
 429         return _ret_var;
 430  }
 431     /// <summary>Sets the scaling factor of an object.
 432     /// (Since EFL 1.22)</summary>
 433     /// <param name="scale">The scaling factor (the default value is 0.0, meaning individual scaling is not set)</param>
 434     /// <returns></returns>
 435     virtual public void SetScale( double scale) {
 436                                  Efl.Gfx.IEntityNativeInherit.efl_gfx_entity_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), scale);
 437         Eina.Error.RaiseIfUnhandledException();
 438                          }
 439     /// <summary>Set the list of commands and points to be used to create the content of path.</summary>
 440     /// <param name="op">Command list</param>
 441     /// <param name="points">Point list</param>
 442     /// <returns></returns>
 443     virtual public void GetPath( out Efl.Gfx.PathCommandType op,  out double points) {
 444                          System.IntPtr _out_op = System.IntPtr.Zero;
 445         System.IntPtr _out_points = System.IntPtr.Zero;
 446                         Efl.Gfx.IPathNativeInherit.efl_gfx_path_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out _out_op,  out _out_points);
 447         Eina.Error.RaiseIfUnhandledException();
 448         op = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.PathCommandType>(_out_op);
 449         points = Eina.PrimitiveConversion.PointerToManaged<double>(_out_points);
 450                          }
 451     /// <summary>Set the list of commands and points to be used to create the content of path.</summary>
 452     /// <param name="op">Command list</param>
 453     /// <param name="points">Point list</param>
 454     /// <returns></returns>
 455     virtual public void SetPath( Efl.Gfx.PathCommandType op,  double points) {
 456          var _in_op = Eina.PrimitiveConversion.ManagedToPointerAlloc(op);
 457         var _in_points = Eina.PrimitiveConversion.ManagedToPointerAlloc(points);
 458                                         Efl.Gfx.IPathNativeInherit.efl_gfx_path_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_op,  _in_points);
 459         Eina.Error.RaiseIfUnhandledException();
 460                                          }
 461     /// <summary>Path length property</summary>
 462     /// <param name="commands">Commands</param>
 463     /// <param name="points">Points</param>
 464     /// <returns></returns>
 465     virtual public void GetLength( out uint commands,  out uint points) {
 466                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_length_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out commands,  out points);
 467         Eina.Error.RaiseIfUnhandledException();
 468                                          }
 469     /// <summary>Current point coordinates</summary>
 470     /// <param name="x">X co-ordinate of the current point.</param>
 471     /// <param name="y">Y co-ordinate of the current point.</param>
 472     /// <returns></returns>
 473     virtual public void GetCurrent( out double x,  out double y) {
 474                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_current_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
 475         Eina.Error.RaiseIfUnhandledException();
 476                                          }
 477     /// <summary>Current control point coordinates</summary>
 478     /// <param name="x">X co-ordinate of control point.</param>
 479     /// <param name="y">Y co-ordinate of control point.</param>
 480     /// <returns></returns>
 481     virtual public void GetCurrentCtrl( out double x,  out double y) {
 482                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_current_ctrl_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
 483         Eina.Error.RaiseIfUnhandledException();
 484                                          }
 485     /// <summary>Copy the path data from the object specified.</summary>
 486     /// <param name="dup_from">Shape object from where data will be copied.</param>
 487     /// <returns></returns>
 488     virtual public void CopyFrom( Efl.Object dup_from) {
 489                                  Efl.Gfx.IPathNativeInherit.efl_gfx_path_copy_from_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dup_from);
 490         Eina.Error.RaiseIfUnhandledException();
 491                          }
 492     /// <summary>Compute and return the bounding box of the currently set path</summary>
 493     /// <param name="r">Contain the bounding box of the currently set path</param>
 494     /// <returns></returns>
 495     virtual public void GetBounds( out Eina.Rect r) {
 496                  var _out_r = new Eina.Rect.NativeStruct();
 497                 Efl.Gfx.IPathNativeInherit.efl_gfx_path_bounds_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out _out_r);
 498         Eina.Error.RaiseIfUnhandledException();
 499         r = _out_r;
 500                  }
 501     /// <summary>Reset the path data of the path object.</summary>
 502     /// <returns></returns>
 503     virtual public void Reset() {
 504          Efl.Gfx.IPathNativeInherit.efl_gfx_path_reset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 505         Eina.Error.RaiseIfUnhandledException();
 506          }
 507     /// <summary>Moves the current point to the given point,  implicitly starting a new subpath and closing the previous one.
 508     /// See also <see cref="Efl.Gfx.IPath.CloseAppend"/>.</summary>
 509     /// <param name="x">X co-ordinate of the current point.</param>
 510     /// <param name="y">Y co-ordinate of the current point.</param>
 511     /// <returns></returns>
 512     virtual public void AppendMoveTo( double x,  double y) {
 513                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_move_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
 514         Eina.Error.RaiseIfUnhandledException();
 515                                          }
 516     /// <summary>Adds a straight line from the current position to the given end point. After the line is drawn, the current position is updated to be at the end point of the line.
 517     /// If no current position present, it draws a line to itself, basically a point.
 518     ///
 519     /// See also <see cref="Efl.Gfx.IPath.AppendMoveTo"/>.</summary>
 520     /// <param name="x">X co-ordinate of end point of the line.</param>
 521     /// <param name="y">Y co-ordinate of end point of the line.</param>
 522     /// <returns></returns>
 523     virtual public void AppendLineTo( double x,  double y) {
 524                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_line_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
 525         Eina.Error.RaiseIfUnhandledException();
 526                                          }
 527     /// <summary>Adds a quadratic Bezier curve between the current position and the given end point (x,y) using the control points specified by (ctrl_x, ctrl_y). After the path is drawn, the current position is updated to be at the end point of the path.</summary>
 528     /// <param name="x">X co-ordinate of end point of the line.</param>
 529     /// <param name="y">Y co-ordinate of end point of the line.</param>
 530     /// <param name="ctrl_x">X co-ordinate of control point.</param>
 531     /// <param name="ctrl_y">Y co-ordinate of control point.</param>
 532     /// <returns></returns>
 533     virtual public void AppendQuadraticTo( double x,  double y,  double ctrl_x,  double ctrl_y) {
 534                                                                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_quadratic_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  ctrl_x,  ctrl_y);
 535         Eina.Error.RaiseIfUnhandledException();
 536                                                                          }
 537     /// <summary>Same as efl_gfx_path_append_quadratic_to() api only difference is that it uses the current control point to draw the bezier.
 538     /// See also <see cref="Efl.Gfx.IPath.AppendQuadraticTo"/>.</summary>
 539     /// <param name="x">X co-ordinate of end point of the line.</param>
 540     /// <param name="y">Y co-ordinate of end point of the line.</param>
 541     /// <returns></returns>
 542     virtual public void AppendSquadraticTo( double x,  double y) {
 543                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_squadratic_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
 544         Eina.Error.RaiseIfUnhandledException();
 545                                          }
 546     /// <summary>Adds a cubic Bezier curve between the current position and the given end point (x,y) using the control points specified by (ctrl_x0, ctrl_y0), and (ctrl_x1, ctrl_y1). After the path is drawn, the current position is updated to be at the end point of the path.</summary>
 547     /// <param name="ctrl_x0">X co-ordinate of 1st control point.</param>
 548     /// <param name="ctrl_y0">Y co-ordinate of 1st control point.</param>
 549     /// <param name="ctrl_x1">X co-ordinate of 2nd control point.</param>
 550     /// <param name="ctrl_y1">Y co-ordinate of 2nd control point.</param>
 551     /// <param name="x">X co-ordinate of end point of the line.</param>
 552     /// <param name="y">Y co-ordinate of end point of the line.</param>
 553     /// <returns></returns>
 554     virtual public void AppendCubicTo( double ctrl_x0,  double ctrl_y0,  double ctrl_x1,  double ctrl_y1,  double x,  double y) {
 555                                                                                                                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_cubic_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ctrl_x0,  ctrl_y0,  ctrl_x1,  ctrl_y1,  x,  y);
 556         Eina.Error.RaiseIfUnhandledException();
 557                                                                                                          }
 558     /// <summary>Same as efl_gfx_path_append_cubic_to() api only difference is that it uses the current control point to draw the bezier.
 559     /// See also <see cref="Efl.Gfx.IPath.AppendCubicTo"/>.</summary>
 560     /// <param name="x">X co-ordinate of end point of the line.</param>
 561     /// <param name="y">Y co-ordinate of end point of the line.</param>
 562     /// <param name="ctrl_x">X co-ordinate of 2nd control point.</param>
 563     /// <param name="ctrl_y">Y co-ordinate of 2nd control point.</param>
 564     /// <returns></returns>
 565     virtual public void AppendScubicTo( double x,  double y,  double ctrl_x,  double ctrl_y) {
 566                                                                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_scubic_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  ctrl_x,  ctrl_y);
 567         Eina.Error.RaiseIfUnhandledException();
 568                                                                          }
 569     /// <summary>Append an arc that connects from the current point int the point list to the given point (x,y). The arc is defined by the given radius in  x-direction (rx) and radius in y direction (ry).
 570     /// Use this api if you know the end point&apos;s of the arc otherwise use more convenient function <see cref="Efl.Gfx.IPath.AppendArc"/>.</summary>
 571     /// <param name="x">X co-ordinate of end point of the arc.</param>
 572     /// <param name="y">Y co-ordinate of end point of the arc.</param>
 573     /// <param name="rx">Radius of arc in x direction.</param>
 574     /// <param name="ry">Radius of arc in y direction.</param>
 575     /// <param name="angle">X-axis rotation , normally 0.</param>
 576     /// <param name="large_arc">Defines whether to draw the larger arc or smaller arc joining two point.</param>
 577     /// <param name="sweep">Defines whether the arc will be drawn counter-clockwise or clockwise from current point to the end point taking into account the large_arc property.</param>
 578     /// <returns></returns>
 579     virtual public void AppendArcTo( double x,  double y,  double rx,  double ry,  double angle,  bool large_arc,  bool sweep) {
 580                                                                                                                                                                                  Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_arc_to_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  rx,  ry,  angle,  large_arc,  sweep);
 581         Eina.Error.RaiseIfUnhandledException();
 582                                                                                                                          }
 583     /// <summary>Append an arc that enclosed in the given rectangle (x, y, w, h). The angle is defined in counter clock wise , use -ve angle for clockwise arc.</summary>
 584     /// <param name="x">X co-ordinate of the rect.</param>
 585     /// <param name="y">Y co-ordinate of the rect.</param>
 586     /// <param name="w">Width of the rect.</param>
 587     /// <param name="h">Height of the rect.</param>
 588     /// <param name="start_angle">Angle at which the arc will start</param>
 589     /// <param name="sweep_length">@ Length of the arc.</param>
 590     /// <returns></returns>
 591     virtual public void AppendArc( double x,  double y,  double w,  double h,  double start_angle,  double sweep_length) {
 592                                                                                                                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_arc_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  w,  h,  start_angle,  sweep_length);
 593         Eina.Error.RaiseIfUnhandledException();
 594                                                                                                          }
 595     /// <summary>Closes the current subpath by drawing a line to the beginning of the subpath, automatically starting a new path. The current point of the new path is (0, 0).
 596     /// If the subpath does not contain any points, this function does nothing.</summary>
 597     /// <returns></returns>
 598     virtual public void CloseAppend() {
 599          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_close_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 600         Eina.Error.RaiseIfUnhandledException();
 601          }
 602     /// <summary>Append a circle with given center and radius.</summary>
 603     /// <param name="x">X co-ordinate of the center of the circle.</param>
 604     /// <param name="y">Y co-ordinate of the center of the circle.</param>
 605     /// <param name="radius">Radius of the circle.</param>
 606     /// <returns></returns>
 607     virtual public void AppendCircle( double x,  double y,  double radius) {
 608                                                                                  Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_circle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  radius);
 609         Eina.Error.RaiseIfUnhandledException();
 610                                                          }
 611     /// <summary>Append the given rectangle with rounded corner to the path.
 612     /// The xr and yr arguments specify the radii of the ellipses defining the corners of the rounded rectangle.
 613     ///
 614     /// xr and yr are specified in terms of width and height respectively.
 615     ///
 616     /// If xr and yr are 0, then it will draw a rectangle without rounded corner.</summary>
 617     /// <param name="x">X co-ordinate of the rectangle.</param>
 618     /// <param name="y">Y co-ordinate of the rectangle.</param>
 619     /// <param name="w">Width of the rectangle.</param>
 620     /// <param name="h">Height of the rectangle.</param>
 621     /// <param name="rx">The x radius of the rounded corner and should be in range [ 0 to w/2 ]</param>
 622     /// <param name="ry">The y radius of the rounded corner and should be in range [ 0 to h/2 ]</param>
 623     /// <returns></returns>
 624     virtual public void AppendRect( double x,  double y,  double w,  double h,  double rx,  double ry) {
 625                                                                                                                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_rect_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y,  w,  h,  rx,  ry);
 626         Eina.Error.RaiseIfUnhandledException();
 627                                                                                                          }
 628     /// <summary>Append SVG path data</summary>
 629     /// <param name="svg_path_data">SVG path data to append</param>
 630     /// <returns></returns>
 631     virtual public void AppendSvgPath( System.String svg_path_data) {
 632                                  Efl.Gfx.IPathNativeInherit.efl_gfx_path_append_svg_path_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), svg_path_data);
 633         Eina.Error.RaiseIfUnhandledException();
 634                          }
 635     /// <summary>Creates intermediary path part-way between two paths
 636     /// Sets the points of the <c>obj</c> as the linear interpolation of the points in the <c>from</c> and <c>to</c> paths.  The path&apos;s x,y position and control point coordinates are likewise interpolated.
 637     ///
 638     /// The <c>from</c> and <c>to</c> paths must not already have equivalent points, and <c>to</c> must contain at least as many points as <c>from</c>, else the function returns <c>false</c> with no interpolation performed.  If <c>to</c> has more points than <c>from</c>, the excess points are ignored.</summary>
 639     /// <param name="from">Source path</param>
 640     /// <param name="to">Destination path</param>
 641     /// <param name="pos_map">Position map in range 0.0 to 1.0</param>
 642     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 643     virtual public bool Interpolate( Efl.Object from,  Efl.Object to,  double pos_map) {
 644                                                                                  var _ret_var = Efl.Gfx.IPathNativeInherit.efl_gfx_path_interpolate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), from,  to,  pos_map);
 645         Eina.Error.RaiseIfUnhandledException();
 646                                                         return _ret_var;
 647  }
 648     /// <summary>Equal commands in object</summary>
 649     /// <param name="with">Object</param>
 650     /// <returns>True on success, <c>false</c> otherwise</returns>
 651     virtual public bool EqualCommands( Efl.Object with) {
 652                                  var _ret_var = Efl.Gfx.IPathNativeInherit.efl_gfx_path_equal_commands_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), with);
 653         Eina.Error.RaiseIfUnhandledException();
 654                         return _ret_var;
 655  }
 656     /// <summary>Reserve path commands buffer in advance. If you know the count of path commands coming, you can reserve commands buffer in advance to avoid buffer growing job.</summary>
 657     /// <param name="cmd_count">Commands count to reserve</param>
 658     /// <param name="pts_count">Pointers count to reserve</param>
 659     /// <returns></returns>
 660     virtual public void Reserve( uint cmd_count,  uint pts_count) {
 661                                                          Efl.Gfx.IPathNativeInherit.efl_gfx_path_reserve_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), cmd_count,  pts_count);
 662         Eina.Error.RaiseIfUnhandledException();
 663                                          }
 664     /// <summary>Request to update the path object.
 665     /// One path object may get appending several path calls (such as append_cubic, append_rect, etc) to construct the final path data. Here commit means all path data is prepared and now object could update its own internal status based on the last path information.</summary>
 666     /// <returns></returns>
 667     virtual public void Commit() {
 668          Efl.Gfx.IPathNativeInherit.efl_gfx_path_commit_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 669         Eina.Error.RaiseIfUnhandledException();
 670          }
 671     /// <summary>Retrieves the layer of its canvas that the given object is part of.
 672     /// See also <see cref="Efl.Gfx.IStack.SetLayer"/>
 673     /// (Since EFL 1.22)</summary>
 674     /// <returns>The number of the layer to place the object on. Must be between <see cref="Efl.Gfx.Constants.StackLayerMin"/> and <see cref="Efl.Gfx.Constants.StackLayerMax"/>.</returns>
 675     virtual public short GetLayer() {
 676          var _ret_var = Efl.Gfx.IStackNativeInherit.efl_gfx_stack_layer_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 677         Eina.Error.RaiseIfUnhandledException();
 678         return _ret_var;
 679  }
 680     /// <summary>Sets the layer of its canvas that the given object will be part of.
 681     /// If you don&apos;t use this function, you&apos;ll be dealing with an unique layer of objects (the default one). Additional layers are handy when you don&apos;t want a set of objects to interfere with another set with regard to stacking. Two layers are completely disjoint in that matter.
 682     ///
 683     /// This is a low-level function, which you&apos;d be using when something should be always on top, for example.
 684     ///
 685     /// Warning: Don&apos;t change the layer of smart objects&apos; children. Smart objects have a layer of their own, which should contain all their child objects.
 686     ///
 687     /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>
 688     /// (Since EFL 1.22)</summary>
 689     /// <param name="l">The number of the layer to place the object on. Must be between <see cref="Efl.Gfx.Constants.StackLayerMin"/> and <see cref="Efl.Gfx.Constants.StackLayerMax"/>.</param>
 690     /// <returns></returns>
 691     virtual public void SetLayer( short l) {
 692                                  Efl.Gfx.IStackNativeInherit.efl_gfx_stack_layer_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), l);
 693         Eina.Error.RaiseIfUnhandledException();
 694                          }
 695     /// <summary>Get the Evas object stacked right below <c>obj</c>
 696     /// This function will traverse layers in its search, if there are objects on layers below the one <c>obj</c> is placed at.
 697     ///
 698     /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.GetBelow"/>
 699     /// (Since EFL 1.22)</summary>
 700     /// <returns>The <see cref="Efl.Gfx.IStack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</returns>
 701     virtual public Efl.Gfx.IStack GetBelow() {
 702          var _ret_var = Efl.Gfx.IStackNativeInherit.efl_gfx_stack_below_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 703         Eina.Error.RaiseIfUnhandledException();
 704         return _ret_var;
 705  }
 706     /// <summary>Get the Evas object stacked right above <c>obj</c>
 707     /// This function will traverse layers in its search, if there are objects on layers above the one <c>obj</c> is placed at.
 708     ///
 709     /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.GetBelow"/>
 710     /// (Since EFL 1.22)</summary>
 711     /// <returns>The <see cref="Efl.Gfx.IStack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</returns>
 712     virtual public Efl.Gfx.IStack GetAbove() {
 713          var _ret_var = Efl.Gfx.IStackNativeInherit.efl_gfx_stack_above_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 714         Eina.Error.RaiseIfUnhandledException();
 715         return _ret_var;
 716  }
 717     /// <summary>Stack <c>obj</c> immediately <c>below</c>
 718     /// Objects, in a given canvas, are stacked in the order they&apos;re added. This means that, if they overlap, the highest ones will cover the lowest ones, in that order. This function is a way to change the stacking order for the objects.
 719     ///
 720     /// Its intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).
 721     ///
 722     /// If you have smart objects on your canvas and <c>obj</c> is a member of one of them, then <c>below</c> must also be a member of the same smart object.
 723     ///
 724     /// Similarly, if <c>obj</c> is not a member of a smart object, <c>below</c> must not be either.
 725     ///
 726     /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.StackBelow"/>
 727     /// (Since EFL 1.22)</summary>
 728     /// <param name="below">The object below which to stack</param>
 729     /// <returns></returns>
 730     virtual public void StackBelow( Efl.Gfx.IStack below) {
 731                                  Efl.Gfx.IStackNativeInherit.efl_gfx_stack_below_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), below);
 732         Eina.Error.RaiseIfUnhandledException();
 733                          }
 734     /// <summary>Raise <c>obj</c> to the top of its layer.
 735     /// <c>obj</c> will, then, be the highest one in the layer it belongs to. Object on other layers won&apos;t get touched.
 736     ///
 737     /// See also <see cref="Efl.Gfx.IStack.StackAbove"/>, <see cref="Efl.Gfx.IStack.StackBelow"/> and <see cref="Efl.Gfx.IStack.LowerToBottom"/>
 738     /// (Since EFL 1.22)</summary>
 739     /// <returns></returns>
 740     virtual public void RaiseToTop() {
 741          Efl.Gfx.IStackNativeInherit.efl_gfx_stack_raise_to_top_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 742         Eina.Error.RaiseIfUnhandledException();
 743          }
 744     /// <summary>Stack <c>obj</c> immediately <c>above</c>
 745     /// Objects, in a given canvas, are stacked in the order they&apos;re added. This means that, if they overlap, the highest ones will cover the lowest ones, in that order. This function is a way to change the stacking order for the objects.
 746     ///
 747     /// Its intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).
 748     ///
 749     /// If you have smart objects on your canvas and <c>obj</c> is a member of one of them, then <c>above</c> must also be a member of the same smart object.
 750     ///
 751     /// Similarly, if <c>obj</c> is not a member of a smart object, <c>above</c> must not be either.
 752     ///
 753     /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.StackBelow"/>
 754     /// (Since EFL 1.22)</summary>
 755     /// <param name="above">The object above which to stack</param>
 756     /// <returns></returns>
 757     virtual public void StackAbove( Efl.Gfx.IStack above) {
 758                                  Efl.Gfx.IStackNativeInherit.efl_gfx_stack_above_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), above);
 759         Eina.Error.RaiseIfUnhandledException();
 760                          }
 761     /// <summary>Lower <c>obj</c> to the bottom of its layer.
 762     /// <c>obj</c> will, then, be the lowest one in the layer it belongs to. Objects on other layers won&apos;t get touched.
 763     ///
 764     /// See also <see cref="Efl.Gfx.IStack.StackAbove"/>, <see cref="Efl.Gfx.IStack.StackBelow"/> and <see cref="Efl.Gfx.IStack.RaiseToTop"/>
 765     /// (Since EFL 1.22)</summary>
 766     /// <returns></returns>
 767     virtual public void LowerToBottom() {
 768          Efl.Gfx.IStackNativeInherit.efl_gfx_stack_lower_to_bottom_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 769         Eina.Error.RaiseIfUnhandledException();
 770          }
 771     /// <summary>Gets the transformation matrix used for this node object.</summary>
 772 /// <value>Transformation matrix.</value>
 773     public Eina.Matrix3 Transformation {
 774         get { return GetTransformation(); }
 775         set { SetTransformation( ref value); }
 776     }
 777     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 778 /// (Since EFL 1.22)</summary>
 779 /// <value>the hex color code.</value>
 780     public System.String ColorCode {
 781         get { return GetColorCode(); }
 782         set { SetColorCode( value); }
 783     }
 784     /// <summary>The 2D position of a canvas object.
 785 /// The position is absolute, in pixels, relative to the top-left corner of the window, within its border decorations (application space).
 786 /// (Since EFL 1.22)</summary>
 787 /// <value>A 2D coordinate in pixel units.</value>
 788     public Eina.Position2D Position {
 789         get { return GetPosition(); }
 790         set { SetPosition( value); }
 791     }
 792     /// <summary>The 2D size of a canvas object.
 793 /// (Since EFL 1.22)</summary>
 794 /// <value>A 2D size in pixel units.</value>
 795     public Eina.Size2D Size {
 796         get { return GetSize(); }
 797         set { SetSize( value); }
 798     }
 799     /// <summary>Rectangular geometry that combines both position and size.
 800 /// (Since EFL 1.22)</summary>
 801 /// <value>The X,Y position and W,H size, in pixels.</value>
 802     public Eina.Rect Geometry {
 803         get { return GetGeometry(); }
 804         set { SetGeometry( value); }
 805     }
 806     /// <summary>The visibility of a canvas object.
 807 /// 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.
 808 ///
 809 /// 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...
 810 /// (Since EFL 1.22)</summary>
 811 /// <value><c>true</c> if to make the object visible, <c>false</c> otherwise</value>
 812     public bool Visible {
 813         get { return GetVisible(); }
 814         set { SetVisible( value); }
 815     }
 816     /// <summary>The scaling factor of an object.
 817 /// 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.
 818 ///
 819 /// 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.
 820 /// (Since EFL 1.22)</summary>
 821 /// <value>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</value>
 822     public double Scale {
 823         get { return GetScale(); }
 824         set { SetScale( value); }
 825     }
 826     /// <summary>Retrieves the layer of its canvas that the given object is part of.
 827 /// See also <see cref="Efl.Gfx.IStack.SetLayer"/>
 828 /// (Since EFL 1.22)</summary>
 829 /// <value>The number of the layer to place the object on. Must be between <see cref="Efl.Gfx.Constants.StackLayerMin"/> and <see cref="Efl.Gfx.Constants.StackLayerMax"/>.</value>
 830     public short Layer {
 831         get { return GetLayer(); }
 832         set { SetLayer( value); }
 833     }
 834     /// <summary>Get the Evas object stacked right below <c>obj</c>
 835 /// This function will traverse layers in its search, if there are objects on layers below the one <c>obj</c> is placed at.
 836 ///
 837 /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.GetBelow"/>
 838 /// (Since EFL 1.22)</summary>
 839 /// <value>The <see cref="Efl.Gfx.IStack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</value>
 840     public Efl.Gfx.IStack Below {
 841         get { return GetBelow(); }
 842     }
 843     /// <summary>Get the Evas object stacked right above <c>obj</c>
 844 /// This function will traverse layers in its search, if there are objects on layers above the one <c>obj</c> is placed at.
 845 ///
 846 /// See also <see cref="Efl.Gfx.IStack.GetLayer"/>, <see cref="Efl.Gfx.IStack.SetLayer"/> and <see cref="Efl.Gfx.IStack.GetBelow"/>
 847 /// (Since EFL 1.22)</summary>
 848 /// <value>The <see cref="Efl.Gfx.IStack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</value>
 849     public Efl.Gfx.IStack Above {
 850         get { return GetAbove(); }
 851     }
 852     private static IntPtr GetEflClassStatic()
 853     {
 854         return Efl.Canvas.Vg.Node.efl_canvas_vg_node_class_get();
 855     }
 856 }
 857 public class NodeNativeInherit : Efl.ObjectNativeInherit{
 858     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Evas);
 859     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 860     {
 861         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 862         var methods = Efl.Eo.Globals.GetUserMethods(type);
 863         if (efl_canvas_vg_node_transformation_get_static_delegate == null)
 864             efl_canvas_vg_node_transformation_get_static_delegate = new efl_canvas_vg_node_transformation_get_delegate(transformation_get);
 865         if (methods.FirstOrDefault(m => m.Name == "GetTransformation") != null)
 866             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_vg_node_transformation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_node_transformation_get_static_delegate)});
 867         if (efl_canvas_vg_node_transformation_set_static_delegate == null)
 868             efl_canvas_vg_node_transformation_set_static_delegate = new efl_canvas_vg_node_transformation_set_delegate(transformation_set);
 869         if (methods.FirstOrDefault(m => m.Name == "SetTransformation") != null)
 870             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_vg_node_transformation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_node_transformation_set_static_delegate)});
 871         if (efl_canvas_vg_node_origin_get_static_delegate == null)
 872             efl_canvas_vg_node_origin_get_static_delegate = new efl_canvas_vg_node_origin_get_delegate(origin_get);
 873         if (methods.FirstOrDefault(m => m.Name == "GetOrigin") != null)
 874             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_vg_node_origin_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_node_origin_get_static_delegate)});
 875         if (efl_canvas_vg_node_origin_set_static_delegate == null)
 876             efl_canvas_vg_node_origin_set_static_delegate = new efl_canvas_vg_node_origin_set_delegate(origin_set);
 877         if (methods.FirstOrDefault(m => m.Name == "SetOrigin") != null)
 878             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_vg_node_origin_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_node_origin_set_static_delegate)});
 879         if (efl_canvas_vg_node_mask_set_static_delegate == null)
 880             efl_canvas_vg_node_mask_set_static_delegate = new efl_canvas_vg_node_mask_set_delegate(mask_set);
 881         if (methods.FirstOrDefault(m => m.Name == "SetMask") != null)
 882             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_canvas_vg_node_mask_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_node_mask_set_static_delegate)});
 883         if (efl_duplicate_static_delegate == null)
 884             efl_duplicate_static_delegate = new efl_duplicate_delegate(duplicate);
 885         if (methods.FirstOrDefault(m => m.Name == "DoDuplicate") != null)
 886             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_duplicate"), func = Marshal.GetFunctionPointerForDelegate(efl_duplicate_static_delegate)});
 887         if (efl_gfx_color_get_static_delegate == null)
 888             efl_gfx_color_get_static_delegate = new efl_gfx_color_get_delegate(color_get);
 889         if (methods.FirstOrDefault(m => m.Name == "GetColor") != null)
 890             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_get_static_delegate)});
 891         if (efl_gfx_color_set_static_delegate == null)
 892             efl_gfx_color_set_static_delegate = new efl_gfx_color_set_delegate(color_set);
 893         if (methods.FirstOrDefault(m => m.Name == "SetColor") != null)
 894             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_set_static_delegate)});
 895         if (efl_gfx_color_code_get_static_delegate == null)
 896             efl_gfx_color_code_get_static_delegate = new efl_gfx_color_code_get_delegate(color_code_get);
 897         if (methods.FirstOrDefault(m => m.Name == "GetColorCode") != null)
 898             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_get_static_delegate)});
 899         if (efl_gfx_color_code_set_static_delegate == null)
 900             efl_gfx_color_code_set_static_delegate = new efl_gfx_color_code_set_delegate(color_code_set);
 901         if (methods.FirstOrDefault(m => m.Name == "SetColorCode") != null)
 902             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_color_code_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_set_static_delegate)});
 903         if (efl_gfx_entity_position_get_static_delegate == null)
 904             efl_gfx_entity_position_get_static_delegate = new efl_gfx_entity_position_get_delegate(position_get);
 905         if (methods.FirstOrDefault(m => m.Name == "GetPosition") != null)
 906             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)});
 907         if (efl_gfx_entity_position_set_static_delegate == null)
 908             efl_gfx_entity_position_set_static_delegate = new efl_gfx_entity_position_set_delegate(position_set);
 909         if (methods.FirstOrDefault(m => m.Name == "SetPosition") != null)
 910             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)});
 911         if (efl_gfx_entity_size_get_static_delegate == null)
 912             efl_gfx_entity_size_get_static_delegate = new efl_gfx_entity_size_get_delegate(size_get);
 913         if (methods.FirstOrDefault(m => m.Name == "GetSize") != null)
 914             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)});
 915         if (efl_gfx_entity_size_set_static_delegate == null)
 916             efl_gfx_entity_size_set_static_delegate = new efl_gfx_entity_size_set_delegate(size_set);
 917         if (methods.FirstOrDefault(m => m.Name == "SetSize") != null)
 918             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)});
 919         if (efl_gfx_entity_geometry_get_static_delegate == null)
 920             efl_gfx_entity_geometry_get_static_delegate = new efl_gfx_entity_geometry_get_delegate(geometry_get);
 921         if (methods.FirstOrDefault(m => m.Name == "GetGeometry") != null)
 922             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)});
 923         if (efl_gfx_entity_geometry_set_static_delegate == null)
 924             efl_gfx_entity_geometry_set_static_delegate = new efl_gfx_entity_geometry_set_delegate(geometry_set);
 925         if (methods.FirstOrDefault(m => m.Name == "SetGeometry") != null)
 926             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)});
 927         if (efl_gfx_entity_visible_get_static_delegate == null)
 928             efl_gfx_entity_visible_get_static_delegate = new efl_gfx_entity_visible_get_delegate(visible_get);
 929         if (methods.FirstOrDefault(m => m.Name == "GetVisible") != null)
 930             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)});
 931         if (efl_gfx_entity_visible_set_static_delegate == null)
 932             efl_gfx_entity_visible_set_static_delegate = new efl_gfx_entity_visible_set_delegate(visible_set);
 933         if (methods.FirstOrDefault(m => m.Name == "SetVisible") != null)
 934             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)});
 935         if (efl_gfx_entity_scale_get_static_delegate == null)
 936             efl_gfx_entity_scale_get_static_delegate = new efl_gfx_entity_scale_get_delegate(scale_get);
 937         if (methods.FirstOrDefault(m => m.Name == "GetScale") != null)
 938             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)});
 939         if (efl_gfx_entity_scale_set_static_delegate == null)
 940             efl_gfx_entity_scale_set_static_delegate = new efl_gfx_entity_scale_set_delegate(scale_set);
 941         if (methods.FirstOrDefault(m => m.Name == "SetScale") != null)
 942             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)});
 943         if (efl_gfx_path_get_static_delegate == null)
 944             efl_gfx_path_get_static_delegate = new efl_gfx_path_get_delegate(path_get);
 945         if (methods.FirstOrDefault(m => m.Name == "GetPath") != null)
 946             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_get_static_delegate)});
 947         if (efl_gfx_path_set_static_delegate == null)
 948             efl_gfx_path_set_static_delegate = new efl_gfx_path_set_delegate(path_set);
 949         if (methods.FirstOrDefault(m => m.Name == "SetPath") != null)
 950             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_set_static_delegate)});
 951         if (efl_gfx_path_length_get_static_delegate == null)
 952             efl_gfx_path_length_get_static_delegate = new efl_gfx_path_length_get_delegate(length_get);
 953         if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 954             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_length_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_length_get_static_delegate)});
 955         if (efl_gfx_path_current_get_static_delegate == null)
 956             efl_gfx_path_current_get_static_delegate = new efl_gfx_path_current_get_delegate(current_get);
 957         if (methods.FirstOrDefault(m => m.Name == "GetCurrent") != null)
 958             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_current_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_current_get_static_delegate)});
 959         if (efl_gfx_path_current_ctrl_get_static_delegate == null)
 960             efl_gfx_path_current_ctrl_get_static_delegate = new efl_gfx_path_current_ctrl_get_delegate(current_ctrl_get);
 961         if (methods.FirstOrDefault(m => m.Name == "GetCurrentCtrl") != null)
 962             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_current_ctrl_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_current_ctrl_get_static_delegate)});
 963         if (efl_gfx_path_copy_from_static_delegate == null)
 964             efl_gfx_path_copy_from_static_delegate = new efl_gfx_path_copy_from_delegate(copy_from);
 965         if (methods.FirstOrDefault(m => m.Name == "CopyFrom") != null)
 966             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_copy_from"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_copy_from_static_delegate)});
 967         if (efl_gfx_path_bounds_get_static_delegate == null)
 968             efl_gfx_path_bounds_get_static_delegate = new efl_gfx_path_bounds_get_delegate(bounds_get);
 969         if (methods.FirstOrDefault(m => m.Name == "GetBounds") != null)
 970             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_bounds_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_bounds_get_static_delegate)});
 971         if (efl_gfx_path_reset_static_delegate == null)
 972             efl_gfx_path_reset_static_delegate = new efl_gfx_path_reset_delegate(reset);
 973         if (methods.FirstOrDefault(m => m.Name == "Reset") != null)
 974             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_reset_static_delegate)});
 975         if (efl_gfx_path_append_move_to_static_delegate == null)
 976             efl_gfx_path_append_move_to_static_delegate = new efl_gfx_path_append_move_to_delegate(append_move_to);
 977         if (methods.FirstOrDefault(m => m.Name == "AppendMoveTo") != null)
 978             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_move_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_move_to_static_delegate)});
 979         if (efl_gfx_path_append_line_to_static_delegate == null)
 980             efl_gfx_path_append_line_to_static_delegate = new efl_gfx_path_append_line_to_delegate(append_line_to);
 981         if (methods.FirstOrDefault(m => m.Name == "AppendLineTo") != null)
 982             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_line_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_line_to_static_delegate)});
 983         if (efl_gfx_path_append_quadratic_to_static_delegate == null)
 984             efl_gfx_path_append_quadratic_to_static_delegate = new efl_gfx_path_append_quadratic_to_delegate(append_quadratic_to);
 985         if (methods.FirstOrDefault(m => m.Name == "AppendQuadraticTo") != null)
 986             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_quadratic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_quadratic_to_static_delegate)});
 987         if (efl_gfx_path_append_squadratic_to_static_delegate == null)
 988             efl_gfx_path_append_squadratic_to_static_delegate = new efl_gfx_path_append_squadratic_to_delegate(append_squadratic_to);
 989         if (methods.FirstOrDefault(m => m.Name == "AppendSquadraticTo") != null)
 990             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_squadratic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_squadratic_to_static_delegate)});
 991         if (efl_gfx_path_append_cubic_to_static_delegate == null)
 992             efl_gfx_path_append_cubic_to_static_delegate = new efl_gfx_path_append_cubic_to_delegate(append_cubic_to);
 993         if (methods.FirstOrDefault(m => m.Name == "AppendCubicTo") != null)
 994             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_cubic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_cubic_to_static_delegate)});
 995         if (efl_gfx_path_append_scubic_to_static_delegate == null)
 996             efl_gfx_path_append_scubic_to_static_delegate = new efl_gfx_path_append_scubic_to_delegate(append_scubic_to);
 997         if (methods.FirstOrDefault(m => m.Name == "AppendScubicTo") != null)
 998             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_scubic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_scubic_to_static_delegate)});
 999         if (efl_gfx_path_append_arc_to_static_delegate == null)
1000             efl_gfx_path_append_arc_to_static_delegate = new efl_gfx_path_append_arc_to_delegate(append_arc_to);
1001         if (methods.FirstOrDefault(m => m.Name == "AppendArcTo") != null)
1002             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_arc_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_arc_to_static_delegate)});
1003         if (efl_gfx_path_append_arc_static_delegate == null)
1004             efl_gfx_path_append_arc_static_delegate = new efl_gfx_path_append_arc_delegate(append_arc);
1005         if (methods.FirstOrDefault(m => m.Name == "AppendArc") != null)
1006             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_arc"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_arc_static_delegate)});
1007         if (efl_gfx_path_append_close_static_delegate == null)
1008             efl_gfx_path_append_close_static_delegate = new efl_gfx_path_append_close_delegate(append_close);
1009         if (methods.FirstOrDefault(m => m.Name == "CloseAppend") != null)
1010             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_close"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_close_static_delegate)});
1011         if (efl_gfx_path_append_circle_static_delegate == null)
1012             efl_gfx_path_append_circle_static_delegate = new efl_gfx_path_append_circle_delegate(append_circle);
1013         if (methods.FirstOrDefault(m => m.Name == "AppendCircle") != null)
1014             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_circle"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_circle_static_delegate)});
1015         if (efl_gfx_path_append_rect_static_delegate == null)
1016             efl_gfx_path_append_rect_static_delegate = new efl_gfx_path_append_rect_delegate(append_rect);
1017         if (methods.FirstOrDefault(m => m.Name == "AppendRect") != null)
1018             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_rect"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_rect_static_delegate)});
1019         if (efl_gfx_path_append_svg_path_static_delegate == null)
1020             efl_gfx_path_append_svg_path_static_delegate = new efl_gfx_path_append_svg_path_delegate(append_svg_path);
1021         if (methods.FirstOrDefault(m => m.Name == "AppendSvgPath") != null)
1022             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_append_svg_path"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_svg_path_static_delegate)});
1023         if (efl_gfx_path_interpolate_static_delegate == null)
1024             efl_gfx_path_interpolate_static_delegate = new efl_gfx_path_interpolate_delegate(interpolate);
1025         if (methods.FirstOrDefault(m => m.Name == "Interpolate") != null)
1026             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_interpolate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_interpolate_static_delegate)});
1027         if (efl_gfx_path_equal_commands_static_delegate == null)
1028             efl_gfx_path_equal_commands_static_delegate = new efl_gfx_path_equal_commands_delegate(equal_commands);
1029         if (methods.FirstOrDefault(m => m.Name == "EqualCommands") != null)
1030             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_equal_commands"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_equal_commands_static_delegate)});
1031         if (efl_gfx_path_reserve_static_delegate == null)
1032             efl_gfx_path_reserve_static_delegate = new efl_gfx_path_reserve_delegate(reserve);
1033         if (methods.FirstOrDefault(m => m.Name == "Reserve") != null)
1034             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_reserve"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_reserve_static_delegate)});
1035         if (efl_gfx_path_commit_static_delegate == null)
1036             efl_gfx_path_commit_static_delegate = new efl_gfx_path_commit_delegate(commit);
1037         if (methods.FirstOrDefault(m => m.Name == "Commit") != null)
1038             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_path_commit"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_commit_static_delegate)});
1039         if (efl_gfx_stack_layer_get_static_delegate == null)
1040             efl_gfx_stack_layer_get_static_delegate = new efl_gfx_stack_layer_get_delegate(layer_get);
1041         if (methods.FirstOrDefault(m => m.Name == "GetLayer") != null)
1042             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_layer_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_layer_get_static_delegate)});
1043         if (efl_gfx_stack_layer_set_static_delegate == null)
1044             efl_gfx_stack_layer_set_static_delegate = new efl_gfx_stack_layer_set_delegate(layer_set);
1045         if (methods.FirstOrDefault(m => m.Name == "SetLayer") != null)
1046             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_layer_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_layer_set_static_delegate)});
1047         if (efl_gfx_stack_below_get_static_delegate == null)
1048             efl_gfx_stack_below_get_static_delegate = new efl_gfx_stack_below_get_delegate(below_get);
1049         if (methods.FirstOrDefault(m => m.Name == "GetBelow") != null)
1050             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_below_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_below_get_static_delegate)});
1051         if (efl_gfx_stack_above_get_static_delegate == null)
1052             efl_gfx_stack_above_get_static_delegate = new efl_gfx_stack_above_get_delegate(above_get);
1053         if (methods.FirstOrDefault(m => m.Name == "GetAbove") != null)
1054             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_above_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_above_get_static_delegate)});
1055         if (efl_gfx_stack_below_static_delegate == null)
1056             efl_gfx_stack_below_static_delegate = new efl_gfx_stack_below_delegate(stack_below);
1057         if (methods.FirstOrDefault(m => m.Name == "StackBelow") != null)
1058             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_below"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_below_static_delegate)});
1059         if (efl_gfx_stack_raise_to_top_static_delegate == null)
1060             efl_gfx_stack_raise_to_top_static_delegate = new efl_gfx_stack_raise_to_top_delegate(raise_to_top);
1061         if (methods.FirstOrDefault(m => m.Name == "RaiseToTop") != null)
1062             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_raise_to_top"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_raise_to_top_static_delegate)});
1063         if (efl_gfx_stack_above_static_delegate == null)
1064             efl_gfx_stack_above_static_delegate = new efl_gfx_stack_above_delegate(stack_above);
1065         if (methods.FirstOrDefault(m => m.Name == "StackAbove") != null)
1066             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_above"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_above_static_delegate)});
1067         if (efl_gfx_stack_lower_to_bottom_static_delegate == null)
1068             efl_gfx_stack_lower_to_bottom_static_delegate = new efl_gfx_stack_lower_to_bottom_delegate(lower_to_bottom);
1069         if (methods.FirstOrDefault(m => m.Name == "LowerToBottom") != null)
1070             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_gfx_stack_lower_to_bottom"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_stack_lower_to_bottom_static_delegate)});
1071         descs.AddRange(base.GetEoOps(type));
1072         return descs;
1073     }
1074     public override IntPtr GetEflClass()
1075     {
1076         return Efl.Canvas.Vg.Node.efl_canvas_vg_node_class_get();
1077     }
1078     public static new  IntPtr GetEflClassStatic()
1079     {
1080         return Efl.Canvas.Vg.Node.efl_canvas_vg_node_class_get();
1081     }
1082
1083
1084      private delegate System.IntPtr efl_canvas_vg_node_transformation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1085
1086
1087      public delegate System.IntPtr efl_canvas_vg_node_transformation_get_api_delegate(System.IntPtr obj);
1088      public static Efl.Eo.FunctionWrapper<efl_canvas_vg_node_transformation_get_api_delegate> efl_canvas_vg_node_transformation_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_node_transformation_get_api_delegate>(_Module, "efl_canvas_vg_node_transformation_get");
1089      private static System.IntPtr transformation_get(System.IntPtr obj, System.IntPtr pd)
1090     {
1091         Eina.Log.Debug("function efl_canvas_vg_node_transformation_get was called");
1092         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1093         if(wrapper != null) {
1094                         Eina.Matrix3 _ret_var = default(Eina.Matrix3);
1095             try {
1096                 _ret_var = ((Node)wrapper).GetTransformation();
1097             } catch (Exception e) {
1098                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100             }
1101         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
1102         } else {
1103             return efl_canvas_vg_node_transformation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1104         }
1105     }
1106     private static efl_canvas_vg_node_transformation_get_delegate efl_canvas_vg_node_transformation_get_static_delegate;
1107
1108
1109      private delegate void efl_canvas_vg_node_transformation_set_delegate(System.IntPtr obj, System.IntPtr pd,   ref Eina.Matrix3.NativeStruct m);
1110
1111
1112      public delegate void efl_canvas_vg_node_transformation_set_api_delegate(System.IntPtr obj,   ref Eina.Matrix3.NativeStruct m);
1113      public static Efl.Eo.FunctionWrapper<efl_canvas_vg_node_transformation_set_api_delegate> efl_canvas_vg_node_transformation_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_node_transformation_set_api_delegate>(_Module, "efl_canvas_vg_node_transformation_set");
1114      private static void transformation_set(System.IntPtr obj, System.IntPtr pd,  ref Eina.Matrix3.NativeStruct m)
1115     {
1116         Eina.Log.Debug("function efl_canvas_vg_node_transformation_set was called");
1117         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1118         if(wrapper != null) {
1119                     Eina.Matrix3 _in_m = m;
1120
1121             try {
1122                 ((Node)wrapper).SetTransformation( ref _in_m);
1123             } catch (Exception e) {
1124                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1125                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1126             }
1127                 m = _in_m;
1128                 } else {
1129             efl_canvas_vg_node_transformation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ref m);
1130         }
1131     }
1132     private static efl_canvas_vg_node_transformation_set_delegate efl_canvas_vg_node_transformation_set_static_delegate;
1133
1134
1135      private delegate void efl_canvas_vg_node_origin_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
1136
1137
1138      public delegate void efl_canvas_vg_node_origin_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
1139      public static Efl.Eo.FunctionWrapper<efl_canvas_vg_node_origin_get_api_delegate> efl_canvas_vg_node_origin_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_node_origin_get_api_delegate>(_Module, "efl_canvas_vg_node_origin_get");
1140      private static void origin_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
1141     {
1142         Eina.Log.Debug("function efl_canvas_vg_node_origin_get was called");
1143         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1144         if(wrapper != null) {
1145                                     x = default(double);        y = default(double);
1146             try {
1147                 ((Node)wrapper).GetOrigin( out x,  out y);
1148             } catch (Exception e) {
1149                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1150                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1151             }
1152                                                 } else {
1153             efl_canvas_vg_node_origin_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
1154         }
1155     }
1156     private static efl_canvas_vg_node_origin_get_delegate efl_canvas_vg_node_origin_get_static_delegate;
1157
1158
1159      private delegate void efl_canvas_vg_node_origin_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1160
1161
1162      public delegate void efl_canvas_vg_node_origin_set_api_delegate(System.IntPtr obj,   double x,   double y);
1163      public static Efl.Eo.FunctionWrapper<efl_canvas_vg_node_origin_set_api_delegate> efl_canvas_vg_node_origin_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_node_origin_set_api_delegate>(_Module, "efl_canvas_vg_node_origin_set");
1164      private static void origin_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1165     {
1166         Eina.Log.Debug("function efl_canvas_vg_node_origin_set was called");
1167         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1168         if(wrapper != null) {
1169
1170             try {
1171                 ((Node)wrapper).SetOrigin( x,  y);
1172             } catch (Exception e) {
1173                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1174                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1175             }
1176                                                 } else {
1177             efl_canvas_vg_node_origin_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1178         }
1179     }
1180     private static efl_canvas_vg_node_origin_set_delegate efl_canvas_vg_node_origin_set_static_delegate;
1181
1182
1183      private delegate void efl_canvas_vg_node_mask_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Vg.Node, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Vg.Node mask,   int op);
1184
1185
1186      public delegate void efl_canvas_vg_node_mask_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Vg.Node, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Vg.Node mask,   int op);
1187      public static Efl.Eo.FunctionWrapper<efl_canvas_vg_node_mask_set_api_delegate> efl_canvas_vg_node_mask_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_node_mask_set_api_delegate>(_Module, "efl_canvas_vg_node_mask_set");
1188      private static void mask_set(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Vg.Node mask,  int op)
1189     {
1190         Eina.Log.Debug("function efl_canvas_vg_node_mask_set was called");
1191         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1192         if(wrapper != null) {
1193
1194             try {
1195                 ((Node)wrapper).SetMask( mask,  op);
1196             } catch (Exception e) {
1197                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1198                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1199             }
1200                                                 } else {
1201             efl_canvas_vg_node_mask_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mask,  op);
1202         }
1203     }
1204     private static efl_canvas_vg_node_mask_set_delegate efl_canvas_vg_node_mask_set_static_delegate;
1205
1206
1207     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IDuplicateConcrete, Efl.Eo.OwnTag>))] private delegate Efl.IDuplicate efl_duplicate_delegate(System.IntPtr obj, System.IntPtr pd);
1208
1209
1210     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IDuplicateConcrete, Efl.Eo.OwnTag>))] public delegate Efl.IDuplicate efl_duplicate_api_delegate(System.IntPtr obj);
1211      public static Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate> efl_duplicate_ptr = new Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate>(_Module, "efl_duplicate");
1212      private static Efl.IDuplicate duplicate(System.IntPtr obj, System.IntPtr pd)
1213     {
1214         Eina.Log.Debug("function efl_duplicate was called");
1215         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1216         if(wrapper != null) {
1217                         Efl.IDuplicate _ret_var = default(Efl.IDuplicate);
1218             try {
1219                 _ret_var = ((Node)wrapper).DoDuplicate();
1220             } catch (Exception e) {
1221                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1222                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1223             }
1224         return _ret_var;
1225         } else {
1226             return efl_duplicate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1227         }
1228     }
1229     private static efl_duplicate_delegate efl_duplicate_static_delegate;
1230
1231
1232      private delegate void efl_gfx_color_get_delegate(System.IntPtr obj, System.IntPtr pd,   out int r,   out int g,   out int b,   out int a);
1233
1234
1235      public delegate void efl_gfx_color_get_api_delegate(System.IntPtr obj,   out int r,   out int g,   out int b,   out int a);
1236      public static Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate> efl_gfx_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate>(_Module, "efl_gfx_color_get");
1237      private static void color_get(System.IntPtr obj, System.IntPtr pd,  out int r,  out int g,  out int b,  out int a)
1238     {
1239         Eina.Log.Debug("function efl_gfx_color_get was called");
1240         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1241         if(wrapper != null) {
1242                                                     r = default(int);        g = default(int);        b = default(int);        a = default(int);
1243             try {
1244                 ((Node)wrapper).GetColor( out r,  out g,  out b,  out a);
1245             } catch (Exception e) {
1246                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1247                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1248             }
1249                                                                                 } else {
1250             efl_gfx_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out r,  out g,  out b,  out a);
1251         }
1252     }
1253     private static efl_gfx_color_get_delegate efl_gfx_color_get_static_delegate;
1254
1255
1256      private delegate void efl_gfx_color_set_delegate(System.IntPtr obj, System.IntPtr pd,   int r,   int g,   int b,   int a);
1257
1258
1259      public delegate void efl_gfx_color_set_api_delegate(System.IntPtr obj,   int r,   int g,   int b,   int a);
1260      public static Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate> efl_gfx_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate>(_Module, "efl_gfx_color_set");
1261      private static void color_set(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a)
1262     {
1263         Eina.Log.Debug("function efl_gfx_color_set was called");
1264         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1265         if(wrapper != null) {
1266
1267             try {
1268                 ((Node)wrapper).SetColor( r,  g,  b,  a);
1269             } catch (Exception e) {
1270                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1271                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1272             }
1273                                                                                 } else {
1274             efl_gfx_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  r,  g,  b,  a);
1275         }
1276     }
1277     private static efl_gfx_color_set_delegate efl_gfx_color_set_static_delegate;
1278
1279
1280      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_gfx_color_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
1281
1282
1283      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_gfx_color_code_get_api_delegate(System.IntPtr obj);
1284      public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate> efl_gfx_color_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate>(_Module, "efl_gfx_color_code_get");
1285      private static System.String color_code_get(System.IntPtr obj, System.IntPtr pd)
1286     {
1287         Eina.Log.Debug("function efl_gfx_color_code_get was called");
1288         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1289         if(wrapper != null) {
1290                         System.String _ret_var = default(System.String);
1291             try {
1292                 _ret_var = ((Node)wrapper).GetColorCode();
1293             } catch (Exception e) {
1294                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1295                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1296             }
1297         return _ret_var;
1298         } else {
1299             return efl_gfx_color_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1300         }
1301     }
1302     private static efl_gfx_color_code_get_delegate efl_gfx_color_code_get_static_delegate;
1303
1304
1305      private delegate void efl_gfx_color_code_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String colorcode);
1306
1307
1308      public delegate void efl_gfx_color_code_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String colorcode);
1309      public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate> efl_gfx_color_code_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate>(_Module, "efl_gfx_color_code_set");
1310      private static void color_code_set(System.IntPtr obj, System.IntPtr pd,  System.String colorcode)
1311     {
1312         Eina.Log.Debug("function efl_gfx_color_code_set was called");
1313         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1314         if(wrapper != null) {
1315
1316             try {
1317                 ((Node)wrapper).SetColorCode( colorcode);
1318             } catch (Exception e) {
1319                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1320                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1321             }
1322                                 } else {
1323             efl_gfx_color_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  colorcode);
1324         }
1325     }
1326     private static efl_gfx_color_code_set_delegate efl_gfx_color_code_set_static_delegate;
1327
1328
1329      private delegate Eina.Position2D.NativeStruct efl_gfx_entity_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1330
1331
1332      public delegate Eina.Position2D.NativeStruct efl_gfx_entity_position_get_api_delegate(System.IntPtr obj);
1333      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");
1334      private static Eina.Position2D.NativeStruct position_get(System.IntPtr obj, System.IntPtr pd)
1335     {
1336         Eina.Log.Debug("function efl_gfx_entity_position_get was called");
1337         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1338         if(wrapper != null) {
1339                         Eina.Position2D _ret_var = default(Eina.Position2D);
1340             try {
1341                 _ret_var = ((Node)wrapper).GetPosition();
1342             } catch (Exception e) {
1343                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1344                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1345             }
1346         return _ret_var;
1347         } else {
1348             return efl_gfx_entity_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1349         }
1350     }
1351     private static efl_gfx_entity_position_get_delegate efl_gfx_entity_position_get_static_delegate;
1352
1353
1354      private delegate void efl_gfx_entity_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D.NativeStruct pos);
1355
1356
1357      public delegate void efl_gfx_entity_position_set_api_delegate(System.IntPtr obj,   Eina.Position2D.NativeStruct pos);
1358      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");
1359      private static void position_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos)
1360     {
1361         Eina.Log.Debug("function efl_gfx_entity_position_set was called");
1362         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1363         if(wrapper != null) {
1364                     Eina.Position2D _in_pos = pos;
1365
1366             try {
1367                 ((Node)wrapper).SetPosition( _in_pos);
1368             } catch (Exception e) {
1369                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1370                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1371             }
1372                                 } else {
1373             efl_gfx_entity_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pos);
1374         }
1375     }
1376     private static efl_gfx_entity_position_set_delegate efl_gfx_entity_position_set_static_delegate;
1377
1378
1379      private delegate Eina.Size2D.NativeStruct efl_gfx_entity_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1380
1381
1382      public delegate Eina.Size2D.NativeStruct efl_gfx_entity_size_get_api_delegate(System.IntPtr obj);
1383      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");
1384      private static Eina.Size2D.NativeStruct size_get(System.IntPtr obj, System.IntPtr pd)
1385     {
1386         Eina.Log.Debug("function efl_gfx_entity_size_get was called");
1387         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1388         if(wrapper != null) {
1389                         Eina.Size2D _ret_var = default(Eina.Size2D);
1390             try {
1391                 _ret_var = ((Node)wrapper).GetSize();
1392             } catch (Exception e) {
1393                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1394                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1395             }
1396         return _ret_var;
1397         } else {
1398             return efl_gfx_entity_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1399         }
1400     }
1401     private static efl_gfx_entity_size_get_delegate efl_gfx_entity_size_get_static_delegate;
1402
1403
1404      private delegate void efl_gfx_entity_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D.NativeStruct size);
1405
1406
1407      public delegate void efl_gfx_entity_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D.NativeStruct size);
1408      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");
1409      private static void size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size)
1410     {
1411         Eina.Log.Debug("function efl_gfx_entity_size_set was called");
1412         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1413         if(wrapper != null) {
1414                     Eina.Size2D _in_size = size;
1415
1416             try {
1417                 ((Node)wrapper).SetSize( _in_size);
1418             } catch (Exception e) {
1419                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1420                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1421             }
1422                                 } else {
1423             efl_gfx_entity_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
1424         }
1425     }
1426     private static efl_gfx_entity_size_set_delegate efl_gfx_entity_size_set_static_delegate;
1427
1428
1429      private delegate Eina.Rect.NativeStruct efl_gfx_entity_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
1430
1431
1432      public delegate Eina.Rect.NativeStruct efl_gfx_entity_geometry_get_api_delegate(System.IntPtr obj);
1433      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");
1434      private static Eina.Rect.NativeStruct geometry_get(System.IntPtr obj, System.IntPtr pd)
1435     {
1436         Eina.Log.Debug("function efl_gfx_entity_geometry_get was called");
1437         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1438         if(wrapper != null) {
1439                         Eina.Rect _ret_var = default(Eina.Rect);
1440             try {
1441                 _ret_var = ((Node)wrapper).GetGeometry();
1442             } catch (Exception e) {
1443                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1444                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1445             }
1446         return _ret_var;
1447         } else {
1448             return efl_gfx_entity_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1449         }
1450     }
1451     private static efl_gfx_entity_geometry_get_delegate efl_gfx_entity_geometry_get_static_delegate;
1452
1453
1454      private delegate void efl_gfx_entity_geometry_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect.NativeStruct rect);
1455
1456
1457      public delegate void efl_gfx_entity_geometry_set_api_delegate(System.IntPtr obj,   Eina.Rect.NativeStruct rect);
1458      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");
1459      private static void geometry_set(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect)
1460     {
1461         Eina.Log.Debug("function efl_gfx_entity_geometry_set was called");
1462         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1463         if(wrapper != null) {
1464                     Eina.Rect _in_rect = rect;
1465
1466             try {
1467                 ((Node)wrapper).SetGeometry( _in_rect);
1468             } catch (Exception e) {
1469                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1470                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1471             }
1472                                 } else {
1473             efl_gfx_entity_geometry_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  rect);
1474         }
1475     }
1476     private static efl_gfx_entity_geometry_set_delegate efl_gfx_entity_geometry_set_static_delegate;
1477
1478
1479      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_entity_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
1480
1481
1482      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_entity_visible_get_api_delegate(System.IntPtr obj);
1483      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");
1484      private static bool visible_get(System.IntPtr obj, System.IntPtr pd)
1485     {
1486         Eina.Log.Debug("function efl_gfx_entity_visible_get was called");
1487         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1488         if(wrapper != null) {
1489                         bool _ret_var = default(bool);
1490             try {
1491                 _ret_var = ((Node)wrapper).GetVisible();
1492             } catch (Exception e) {
1493                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1494                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1495             }
1496         return _ret_var;
1497         } else {
1498             return efl_gfx_entity_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1499         }
1500     }
1501     private static efl_gfx_entity_visible_get_delegate efl_gfx_entity_visible_get_static_delegate;
1502
1503
1504      private delegate void efl_gfx_entity_visible_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool v);
1505
1506
1507      public delegate void efl_gfx_entity_visible_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool v);
1508      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");
1509      private static void visible_set(System.IntPtr obj, System.IntPtr pd,  bool v)
1510     {
1511         Eina.Log.Debug("function efl_gfx_entity_visible_set was called");
1512         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1513         if(wrapper != null) {
1514
1515             try {
1516                 ((Node)wrapper).SetVisible( v);
1517             } catch (Exception e) {
1518                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1519                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1520             }
1521                                 } else {
1522             efl_gfx_entity_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  v);
1523         }
1524     }
1525     private static efl_gfx_entity_visible_set_delegate efl_gfx_entity_visible_set_static_delegate;
1526
1527
1528      private delegate double efl_gfx_entity_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1529
1530
1531      public delegate double efl_gfx_entity_scale_get_api_delegate(System.IntPtr obj);
1532      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");
1533      private static double scale_get(System.IntPtr obj, System.IntPtr pd)
1534     {
1535         Eina.Log.Debug("function efl_gfx_entity_scale_get was called");
1536         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1537         if(wrapper != null) {
1538                         double _ret_var = default(double);
1539             try {
1540                 _ret_var = ((Node)wrapper).GetScale();
1541             } catch (Exception e) {
1542                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1543                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1544             }
1545         return _ret_var;
1546         } else {
1547             return efl_gfx_entity_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1548         }
1549     }
1550     private static efl_gfx_entity_scale_get_delegate efl_gfx_entity_scale_get_static_delegate;
1551
1552
1553      private delegate void efl_gfx_entity_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,   double scale);
1554
1555
1556      public delegate void efl_gfx_entity_scale_set_api_delegate(System.IntPtr obj,   double scale);
1557      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");
1558      private static void scale_set(System.IntPtr obj, System.IntPtr pd,  double scale)
1559     {
1560         Eina.Log.Debug("function efl_gfx_entity_scale_set was called");
1561         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1562         if(wrapper != null) {
1563
1564             try {
1565                 ((Node)wrapper).SetScale( scale);
1566             } catch (Exception e) {
1567                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1568                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1569             }
1570                                 } else {
1571             efl_gfx_entity_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scale);
1572         }
1573     }
1574     private static efl_gfx_entity_scale_set_delegate efl_gfx_entity_scale_set_static_delegate;
1575
1576
1577      private delegate void efl_gfx_path_get_delegate(System.IntPtr obj, System.IntPtr pd,   out System.IntPtr op,   out System.IntPtr points);
1578
1579
1580      public delegate void efl_gfx_path_get_api_delegate(System.IntPtr obj,   out System.IntPtr op,   out System.IntPtr points);
1581      public static Efl.Eo.FunctionWrapper<efl_gfx_path_get_api_delegate> efl_gfx_path_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_get_api_delegate>(_Module, "efl_gfx_path_get");
1582      private static void path_get(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr op,  out System.IntPtr points)
1583     {
1584         Eina.Log.Debug("function efl_gfx_path_get was called");
1585         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1586         if(wrapper != null) {
1587                                     Efl.Gfx.PathCommandType _out_op = default(Efl.Gfx.PathCommandType);
1588         double _out_points = default(double);
1589
1590             try {
1591                 ((Node)wrapper).GetPath( out _out_op,  out _out_points);
1592             } catch (Exception e) {
1593                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1594                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1595             }
1596         op = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_op);
1597         points = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_points);
1598                                 } else {
1599             efl_gfx_path_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out op,  out points);
1600         }
1601     }
1602     private static efl_gfx_path_get_delegate efl_gfx_path_get_static_delegate;
1603
1604
1605      private delegate void efl_gfx_path_set_delegate(System.IntPtr obj, System.IntPtr pd,   System.IntPtr op,   System.IntPtr points);
1606
1607
1608      public delegate void efl_gfx_path_set_api_delegate(System.IntPtr obj,   System.IntPtr op,   System.IntPtr points);
1609      public static Efl.Eo.FunctionWrapper<efl_gfx_path_set_api_delegate> efl_gfx_path_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_set_api_delegate>(_Module, "efl_gfx_path_set");
1610      private static void path_set(System.IntPtr obj, System.IntPtr pd,  System.IntPtr op,  System.IntPtr points)
1611     {
1612         Eina.Log.Debug("function efl_gfx_path_set was called");
1613         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1614         if(wrapper != null) {
1615                     var _in_op = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.PathCommandType>(op);
1616         var _in_points = Eina.PrimitiveConversion.PointerToManaged<double>(points);
1617
1618             try {
1619                 ((Node)wrapper).SetPath( _in_op,  _in_points);
1620             } catch (Exception e) {
1621                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1622                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1623             }
1624                                                 } else {
1625             efl_gfx_path_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  op,  points);
1626         }
1627     }
1628     private static efl_gfx_path_set_delegate efl_gfx_path_set_static_delegate;
1629
1630
1631      private delegate void efl_gfx_path_length_get_delegate(System.IntPtr obj, System.IntPtr pd,   out uint commands,   out uint points);
1632
1633
1634      public delegate void efl_gfx_path_length_get_api_delegate(System.IntPtr obj,   out uint commands,   out uint points);
1635      public static Efl.Eo.FunctionWrapper<efl_gfx_path_length_get_api_delegate> efl_gfx_path_length_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_length_get_api_delegate>(_Module, "efl_gfx_path_length_get");
1636      private static void length_get(System.IntPtr obj, System.IntPtr pd,  out uint commands,  out uint points)
1637     {
1638         Eina.Log.Debug("function efl_gfx_path_length_get was called");
1639         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1640         if(wrapper != null) {
1641                                     commands = default(uint);        points = default(uint);
1642             try {
1643                 ((Node)wrapper).GetLength( out commands,  out points);
1644             } catch (Exception e) {
1645                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1646                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1647             }
1648                                                 } else {
1649             efl_gfx_path_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out commands,  out points);
1650         }
1651     }
1652     private static efl_gfx_path_length_get_delegate efl_gfx_path_length_get_static_delegate;
1653
1654
1655      private delegate void efl_gfx_path_current_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
1656
1657
1658      public delegate void efl_gfx_path_current_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
1659      public static Efl.Eo.FunctionWrapper<efl_gfx_path_current_get_api_delegate> efl_gfx_path_current_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_current_get_api_delegate>(_Module, "efl_gfx_path_current_get");
1660      private static void current_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
1661     {
1662         Eina.Log.Debug("function efl_gfx_path_current_get was called");
1663         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1664         if(wrapper != null) {
1665                                     x = default(double);        y = default(double);
1666             try {
1667                 ((Node)wrapper).GetCurrent( out x,  out y);
1668             } catch (Exception e) {
1669                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1670                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1671             }
1672                                                 } else {
1673             efl_gfx_path_current_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
1674         }
1675     }
1676     private static efl_gfx_path_current_get_delegate efl_gfx_path_current_get_static_delegate;
1677
1678
1679      private delegate void efl_gfx_path_current_ctrl_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
1680
1681
1682      public delegate void efl_gfx_path_current_ctrl_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
1683      public static Efl.Eo.FunctionWrapper<efl_gfx_path_current_ctrl_get_api_delegate> efl_gfx_path_current_ctrl_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_current_ctrl_get_api_delegate>(_Module, "efl_gfx_path_current_ctrl_get");
1684      private static void current_ctrl_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
1685     {
1686         Eina.Log.Debug("function efl_gfx_path_current_ctrl_get was called");
1687         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1688         if(wrapper != null) {
1689                                     x = default(double);        y = default(double);
1690             try {
1691                 ((Node)wrapper).GetCurrentCtrl( out x,  out y);
1692             } catch (Exception e) {
1693                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1694                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1695             }
1696                                                 } else {
1697             efl_gfx_path_current_ctrl_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
1698         }
1699     }
1700     private static efl_gfx_path_current_ctrl_get_delegate efl_gfx_path_current_ctrl_get_static_delegate;
1701
1702
1703      private delegate void efl_gfx_path_copy_from_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object dup_from);
1704
1705
1706      public delegate void efl_gfx_path_copy_from_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object dup_from);
1707      public static Efl.Eo.FunctionWrapper<efl_gfx_path_copy_from_api_delegate> efl_gfx_path_copy_from_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_copy_from_api_delegate>(_Module, "efl_gfx_path_copy_from");
1708      private static void copy_from(System.IntPtr obj, System.IntPtr pd,  Efl.Object dup_from)
1709     {
1710         Eina.Log.Debug("function efl_gfx_path_copy_from was called");
1711         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1712         if(wrapper != null) {
1713
1714             try {
1715                 ((Node)wrapper).CopyFrom( dup_from);
1716             } catch (Exception e) {
1717                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1718                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1719             }
1720                                 } else {
1721             efl_gfx_path_copy_from_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dup_from);
1722         }
1723     }
1724     private static efl_gfx_path_copy_from_delegate efl_gfx_path_copy_from_static_delegate;
1725
1726
1727      private delegate void efl_gfx_path_bounds_get_delegate(System.IntPtr obj, System.IntPtr pd,   out Eina.Rect.NativeStruct r);
1728
1729
1730      public delegate void efl_gfx_path_bounds_get_api_delegate(System.IntPtr obj,   out Eina.Rect.NativeStruct r);
1731      public static Efl.Eo.FunctionWrapper<efl_gfx_path_bounds_get_api_delegate> efl_gfx_path_bounds_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_bounds_get_api_delegate>(_Module, "efl_gfx_path_bounds_get");
1732      private static void bounds_get(System.IntPtr obj, System.IntPtr pd,  out Eina.Rect.NativeStruct r)
1733     {
1734         Eina.Log.Debug("function efl_gfx_path_bounds_get was called");
1735         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1736         if(wrapper != null) {
1737                             Eina.Rect _out_r = default(Eina.Rect);
1738
1739             try {
1740                 ((Node)wrapper).GetBounds( out _out_r);
1741             } catch (Exception e) {
1742                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1743                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1744             }
1745         r = _out_r;
1746                         } else {
1747             efl_gfx_path_bounds_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out r);
1748         }
1749     }
1750     private static efl_gfx_path_bounds_get_delegate efl_gfx_path_bounds_get_static_delegate;
1751
1752
1753      private delegate void efl_gfx_path_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1754
1755
1756      public delegate void efl_gfx_path_reset_api_delegate(System.IntPtr obj);
1757      public static Efl.Eo.FunctionWrapper<efl_gfx_path_reset_api_delegate> efl_gfx_path_reset_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_reset_api_delegate>(_Module, "efl_gfx_path_reset");
1758      private static void reset(System.IntPtr obj, System.IntPtr pd)
1759     {
1760         Eina.Log.Debug("function efl_gfx_path_reset was called");
1761         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1762         if(wrapper != null) {
1763
1764             try {
1765                 ((Node)wrapper).Reset();
1766             } catch (Exception e) {
1767                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1768                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1769             }
1770                 } else {
1771             efl_gfx_path_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1772         }
1773     }
1774     private static efl_gfx_path_reset_delegate efl_gfx_path_reset_static_delegate;
1775
1776
1777      private delegate void efl_gfx_path_append_move_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1778
1779
1780      public delegate void efl_gfx_path_append_move_to_api_delegate(System.IntPtr obj,   double x,   double y);
1781      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_move_to_api_delegate> efl_gfx_path_append_move_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_move_to_api_delegate>(_Module, "efl_gfx_path_append_move_to");
1782      private static void append_move_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1783     {
1784         Eina.Log.Debug("function efl_gfx_path_append_move_to was called");
1785         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1786         if(wrapper != null) {
1787
1788             try {
1789                 ((Node)wrapper).AppendMoveTo( x,  y);
1790             } catch (Exception e) {
1791                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1792                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1793             }
1794                                                 } else {
1795             efl_gfx_path_append_move_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1796         }
1797     }
1798     private static efl_gfx_path_append_move_to_delegate efl_gfx_path_append_move_to_static_delegate;
1799
1800
1801      private delegate void efl_gfx_path_append_line_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1802
1803
1804      public delegate void efl_gfx_path_append_line_to_api_delegate(System.IntPtr obj,   double x,   double y);
1805      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_line_to_api_delegate> efl_gfx_path_append_line_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_line_to_api_delegate>(_Module, "efl_gfx_path_append_line_to");
1806      private static void append_line_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1807     {
1808         Eina.Log.Debug("function efl_gfx_path_append_line_to was called");
1809         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1810         if(wrapper != null) {
1811
1812             try {
1813                 ((Node)wrapper).AppendLineTo( x,  y);
1814             } catch (Exception e) {
1815                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1816                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1817             }
1818                                                 } else {
1819             efl_gfx_path_append_line_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1820         }
1821     }
1822     private static efl_gfx_path_append_line_to_delegate efl_gfx_path_append_line_to_static_delegate;
1823
1824
1825      private delegate void efl_gfx_path_append_quadratic_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double ctrl_x,   double ctrl_y);
1826
1827
1828      public delegate void efl_gfx_path_append_quadratic_to_api_delegate(System.IntPtr obj,   double x,   double y,   double ctrl_x,   double ctrl_y);
1829      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_quadratic_to_api_delegate> efl_gfx_path_append_quadratic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_quadratic_to_api_delegate>(_Module, "efl_gfx_path_append_quadratic_to");
1830      private static void append_quadratic_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double ctrl_x,  double ctrl_y)
1831     {
1832         Eina.Log.Debug("function efl_gfx_path_append_quadratic_to was called");
1833         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1834         if(wrapper != null) {
1835
1836             try {
1837                 ((Node)wrapper).AppendQuadraticTo( x,  y,  ctrl_x,  ctrl_y);
1838             } catch (Exception e) {
1839                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1840                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1841             }
1842                                                                                 } else {
1843             efl_gfx_path_append_quadratic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  ctrl_x,  ctrl_y);
1844         }
1845     }
1846     private static efl_gfx_path_append_quadratic_to_delegate efl_gfx_path_append_quadratic_to_static_delegate;
1847
1848
1849      private delegate void efl_gfx_path_append_squadratic_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
1850
1851
1852      public delegate void efl_gfx_path_append_squadratic_to_api_delegate(System.IntPtr obj,   double x,   double y);
1853      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_squadratic_to_api_delegate> efl_gfx_path_append_squadratic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_squadratic_to_api_delegate>(_Module, "efl_gfx_path_append_squadratic_to");
1854      private static void append_squadratic_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
1855     {
1856         Eina.Log.Debug("function efl_gfx_path_append_squadratic_to was called");
1857         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1858         if(wrapper != null) {
1859
1860             try {
1861                 ((Node)wrapper).AppendSquadraticTo( x,  y);
1862             } catch (Exception e) {
1863                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1864                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1865             }
1866                                                 } else {
1867             efl_gfx_path_append_squadratic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
1868         }
1869     }
1870     private static efl_gfx_path_append_squadratic_to_delegate efl_gfx_path_append_squadratic_to_static_delegate;
1871
1872
1873      private delegate void efl_gfx_path_append_cubic_to_delegate(System.IntPtr obj, System.IntPtr pd,   double ctrl_x0,   double ctrl_y0,   double ctrl_x1,   double ctrl_y1,   double x,   double y);
1874
1875
1876      public delegate void efl_gfx_path_append_cubic_to_api_delegate(System.IntPtr obj,   double ctrl_x0,   double ctrl_y0,   double ctrl_x1,   double ctrl_y1,   double x,   double y);
1877      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_cubic_to_api_delegate> efl_gfx_path_append_cubic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_cubic_to_api_delegate>(_Module, "efl_gfx_path_append_cubic_to");
1878      private static void append_cubic_to(System.IntPtr obj, System.IntPtr pd,  double ctrl_x0,  double ctrl_y0,  double ctrl_x1,  double ctrl_y1,  double x,  double y)
1879     {
1880         Eina.Log.Debug("function efl_gfx_path_append_cubic_to was called");
1881         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1882         if(wrapper != null) {
1883
1884             try {
1885                 ((Node)wrapper).AppendCubicTo( ctrl_x0,  ctrl_y0,  ctrl_x1,  ctrl_y1,  x,  y);
1886             } catch (Exception e) {
1887                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1888                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1889             }
1890                                                                                                                 } else {
1891             efl_gfx_path_append_cubic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ctrl_x0,  ctrl_y0,  ctrl_x1,  ctrl_y1,  x,  y);
1892         }
1893     }
1894     private static efl_gfx_path_append_cubic_to_delegate efl_gfx_path_append_cubic_to_static_delegate;
1895
1896
1897      private delegate void efl_gfx_path_append_scubic_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double ctrl_x,   double ctrl_y);
1898
1899
1900      public delegate void efl_gfx_path_append_scubic_to_api_delegate(System.IntPtr obj,   double x,   double y,   double ctrl_x,   double ctrl_y);
1901      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_scubic_to_api_delegate> efl_gfx_path_append_scubic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_scubic_to_api_delegate>(_Module, "efl_gfx_path_append_scubic_to");
1902      private static void append_scubic_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double ctrl_x,  double ctrl_y)
1903     {
1904         Eina.Log.Debug("function efl_gfx_path_append_scubic_to was called");
1905         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1906         if(wrapper != null) {
1907
1908             try {
1909                 ((Node)wrapper).AppendScubicTo( x,  y,  ctrl_x,  ctrl_y);
1910             } catch (Exception e) {
1911                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1912                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1913             }
1914                                                                                 } else {
1915             efl_gfx_path_append_scubic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  ctrl_x,  ctrl_y);
1916         }
1917     }
1918     private static efl_gfx_path_append_scubic_to_delegate efl_gfx_path_append_scubic_to_static_delegate;
1919
1920
1921      private delegate void efl_gfx_path_append_arc_to_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double rx,   double ry,   double angle,  [MarshalAs(UnmanagedType.U1)]  bool large_arc,  [MarshalAs(UnmanagedType.U1)]  bool sweep);
1922
1923
1924      public delegate void efl_gfx_path_append_arc_to_api_delegate(System.IntPtr obj,   double x,   double y,   double rx,   double ry,   double angle,  [MarshalAs(UnmanagedType.U1)]  bool large_arc,  [MarshalAs(UnmanagedType.U1)]  bool sweep);
1925      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_to_api_delegate> efl_gfx_path_append_arc_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_to_api_delegate>(_Module, "efl_gfx_path_append_arc_to");
1926      private static void append_arc_to(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double rx,  double ry,  double angle,  bool large_arc,  bool sweep)
1927     {
1928         Eina.Log.Debug("function efl_gfx_path_append_arc_to was called");
1929         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1930         if(wrapper != null) {
1931
1932             try {
1933                 ((Node)wrapper).AppendArcTo( x,  y,  rx,  ry,  angle,  large_arc,  sweep);
1934             } catch (Exception e) {
1935                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1936                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1937             }
1938                                                                                                                                 } else {
1939             efl_gfx_path_append_arc_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  rx,  ry,  angle,  large_arc,  sweep);
1940         }
1941     }
1942     private static efl_gfx_path_append_arc_to_delegate efl_gfx_path_append_arc_to_static_delegate;
1943
1944
1945      private delegate void efl_gfx_path_append_arc_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double w,   double h,   double start_angle,   double sweep_length);
1946
1947
1948      public delegate void efl_gfx_path_append_arc_api_delegate(System.IntPtr obj,   double x,   double y,   double w,   double h,   double start_angle,   double sweep_length);
1949      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_api_delegate> efl_gfx_path_append_arc_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_api_delegate>(_Module, "efl_gfx_path_append_arc");
1950      private static void append_arc(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double w,  double h,  double start_angle,  double sweep_length)
1951     {
1952         Eina.Log.Debug("function efl_gfx_path_append_arc was called");
1953         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1954         if(wrapper != null) {
1955
1956             try {
1957                 ((Node)wrapper).AppendArc( x,  y,  w,  h,  start_angle,  sweep_length);
1958             } catch (Exception e) {
1959                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1960                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1961             }
1962                                                                                                                 } else {
1963             efl_gfx_path_append_arc_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  w,  h,  start_angle,  sweep_length);
1964         }
1965     }
1966     private static efl_gfx_path_append_arc_delegate efl_gfx_path_append_arc_static_delegate;
1967
1968
1969      private delegate void efl_gfx_path_append_close_delegate(System.IntPtr obj, System.IntPtr pd);
1970
1971
1972      public delegate void efl_gfx_path_append_close_api_delegate(System.IntPtr obj);
1973      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_close_api_delegate> efl_gfx_path_append_close_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_close_api_delegate>(_Module, "efl_gfx_path_append_close");
1974      private static void append_close(System.IntPtr obj, System.IntPtr pd)
1975     {
1976         Eina.Log.Debug("function efl_gfx_path_append_close was called");
1977         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1978         if(wrapper != null) {
1979
1980             try {
1981                 ((Node)wrapper).CloseAppend();
1982             } catch (Exception e) {
1983                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1984                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1985             }
1986                 } else {
1987             efl_gfx_path_append_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1988         }
1989     }
1990     private static efl_gfx_path_append_close_delegate efl_gfx_path_append_close_static_delegate;
1991
1992
1993      private delegate void efl_gfx_path_append_circle_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double radius);
1994
1995
1996      public delegate void efl_gfx_path_append_circle_api_delegate(System.IntPtr obj,   double x,   double y,   double radius);
1997      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_circle_api_delegate> efl_gfx_path_append_circle_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_circle_api_delegate>(_Module, "efl_gfx_path_append_circle");
1998      private static void append_circle(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double radius)
1999     {
2000         Eina.Log.Debug("function efl_gfx_path_append_circle was called");
2001         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2002         if(wrapper != null) {
2003
2004             try {
2005                 ((Node)wrapper).AppendCircle( x,  y,  radius);
2006             } catch (Exception e) {
2007                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2008                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2009             }
2010                                                                 } else {
2011             efl_gfx_path_append_circle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  radius);
2012         }
2013     }
2014     private static efl_gfx_path_append_circle_delegate efl_gfx_path_append_circle_static_delegate;
2015
2016
2017      private delegate void efl_gfx_path_append_rect_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y,   double w,   double h,   double rx,   double ry);
2018
2019
2020      public delegate void efl_gfx_path_append_rect_api_delegate(System.IntPtr obj,   double x,   double y,   double w,   double h,   double rx,   double ry);
2021      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_rect_api_delegate> efl_gfx_path_append_rect_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_rect_api_delegate>(_Module, "efl_gfx_path_append_rect");
2022      private static void append_rect(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double w,  double h,  double rx,  double ry)
2023     {
2024         Eina.Log.Debug("function efl_gfx_path_append_rect was called");
2025         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2026         if(wrapper != null) {
2027
2028             try {
2029                 ((Node)wrapper).AppendRect( x,  y,  w,  h,  rx,  ry);
2030             } catch (Exception e) {
2031                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2032                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2033             }
2034                                                                                                                 } else {
2035             efl_gfx_path_append_rect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y,  w,  h,  rx,  ry);
2036         }
2037     }
2038     private static efl_gfx_path_append_rect_delegate efl_gfx_path_append_rect_static_delegate;
2039
2040
2041      private delegate void efl_gfx_path_append_svg_path_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String svg_path_data);
2042
2043
2044      public delegate void efl_gfx_path_append_svg_path_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String svg_path_data);
2045      public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_svg_path_api_delegate> efl_gfx_path_append_svg_path_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_svg_path_api_delegate>(_Module, "efl_gfx_path_append_svg_path");
2046      private static void append_svg_path(System.IntPtr obj, System.IntPtr pd,  System.String svg_path_data)
2047     {
2048         Eina.Log.Debug("function efl_gfx_path_append_svg_path was called");
2049         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2050         if(wrapper != null) {
2051
2052             try {
2053                 ((Node)wrapper).AppendSvgPath( svg_path_data);
2054             } catch (Exception e) {
2055                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2056                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2057             }
2058                                 } else {
2059             efl_gfx_path_append_svg_path_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  svg_path_data);
2060         }
2061     }
2062     private static efl_gfx_path_append_svg_path_delegate efl_gfx_path_append_svg_path_static_delegate;
2063
2064
2065      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_path_interpolate_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object from, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object to,   double pos_map);
2066
2067
2068      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_path_interpolate_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object from, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object to,   double pos_map);
2069      public static Efl.Eo.FunctionWrapper<efl_gfx_path_interpolate_api_delegate> efl_gfx_path_interpolate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_interpolate_api_delegate>(_Module, "efl_gfx_path_interpolate");
2070      private static bool interpolate(System.IntPtr obj, System.IntPtr pd,  Efl.Object from,  Efl.Object to,  double pos_map)
2071     {
2072         Eina.Log.Debug("function efl_gfx_path_interpolate was called");
2073         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2074         if(wrapper != null) {
2075                                                                                                 bool _ret_var = default(bool);
2076             try {
2077                 _ret_var = ((Node)wrapper).Interpolate( from,  to,  pos_map);
2078             } catch (Exception e) {
2079                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2080                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2081             }
2082                                                         return _ret_var;
2083         } else {
2084             return efl_gfx_path_interpolate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  from,  to,  pos_map);
2085         }
2086     }
2087     private static efl_gfx_path_interpolate_delegate efl_gfx_path_interpolate_static_delegate;
2088
2089
2090      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_path_equal_commands_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object with);
2091
2092
2093      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_path_equal_commands_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))]  Efl.Object with);
2094      public static Efl.Eo.FunctionWrapper<efl_gfx_path_equal_commands_api_delegate> efl_gfx_path_equal_commands_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_equal_commands_api_delegate>(_Module, "efl_gfx_path_equal_commands");
2095      private static bool equal_commands(System.IntPtr obj, System.IntPtr pd,  Efl.Object with)
2096     {
2097         Eina.Log.Debug("function efl_gfx_path_equal_commands was called");
2098         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2099         if(wrapper != null) {
2100                                                 bool _ret_var = default(bool);
2101             try {
2102                 _ret_var = ((Node)wrapper).EqualCommands( with);
2103             } catch (Exception e) {
2104                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2105                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2106             }
2107                         return _ret_var;
2108         } else {
2109             return efl_gfx_path_equal_commands_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  with);
2110         }
2111     }
2112     private static efl_gfx_path_equal_commands_delegate efl_gfx_path_equal_commands_static_delegate;
2113
2114
2115      private delegate void efl_gfx_path_reserve_delegate(System.IntPtr obj, System.IntPtr pd,   uint cmd_count,   uint pts_count);
2116
2117
2118      public delegate void efl_gfx_path_reserve_api_delegate(System.IntPtr obj,   uint cmd_count,   uint pts_count);
2119      public static Efl.Eo.FunctionWrapper<efl_gfx_path_reserve_api_delegate> efl_gfx_path_reserve_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_reserve_api_delegate>(_Module, "efl_gfx_path_reserve");
2120      private static void reserve(System.IntPtr obj, System.IntPtr pd,  uint cmd_count,  uint pts_count)
2121     {
2122         Eina.Log.Debug("function efl_gfx_path_reserve was called");
2123         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2124         if(wrapper != null) {
2125
2126             try {
2127                 ((Node)wrapper).Reserve( cmd_count,  pts_count);
2128             } catch (Exception e) {
2129                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2130                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2131             }
2132                                                 } else {
2133             efl_gfx_path_reserve_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cmd_count,  pts_count);
2134         }
2135     }
2136     private static efl_gfx_path_reserve_delegate efl_gfx_path_reserve_static_delegate;
2137
2138
2139      private delegate void efl_gfx_path_commit_delegate(System.IntPtr obj, System.IntPtr pd);
2140
2141
2142      public delegate void efl_gfx_path_commit_api_delegate(System.IntPtr obj);
2143      public static Efl.Eo.FunctionWrapper<efl_gfx_path_commit_api_delegate> efl_gfx_path_commit_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_commit_api_delegate>(_Module, "efl_gfx_path_commit");
2144      private static void commit(System.IntPtr obj, System.IntPtr pd)
2145     {
2146         Eina.Log.Debug("function efl_gfx_path_commit was called");
2147         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2148         if(wrapper != null) {
2149
2150             try {
2151                 ((Node)wrapper).Commit();
2152             } catch (Exception e) {
2153                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2154                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2155             }
2156                 } else {
2157             efl_gfx_path_commit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2158         }
2159     }
2160     private static efl_gfx_path_commit_delegate efl_gfx_path_commit_static_delegate;
2161
2162
2163      private delegate short efl_gfx_stack_layer_get_delegate(System.IntPtr obj, System.IntPtr pd);
2164
2165
2166      public delegate short efl_gfx_stack_layer_get_api_delegate(System.IntPtr obj);
2167      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_layer_get_api_delegate> efl_gfx_stack_layer_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_layer_get_api_delegate>(_Module, "efl_gfx_stack_layer_get");
2168      private static short layer_get(System.IntPtr obj, System.IntPtr pd)
2169     {
2170         Eina.Log.Debug("function efl_gfx_stack_layer_get was called");
2171         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2172         if(wrapper != null) {
2173                         short _ret_var = default(short);
2174             try {
2175                 _ret_var = ((Node)wrapper).GetLayer();
2176             } catch (Exception e) {
2177                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2178                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2179             }
2180         return _ret_var;
2181         } else {
2182             return efl_gfx_stack_layer_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2183         }
2184     }
2185     private static efl_gfx_stack_layer_get_delegate efl_gfx_stack_layer_get_static_delegate;
2186
2187
2188      private delegate void efl_gfx_stack_layer_set_delegate(System.IntPtr obj, System.IntPtr pd,   short l);
2189
2190
2191      public delegate void efl_gfx_stack_layer_set_api_delegate(System.IntPtr obj,   short l);
2192      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_layer_set_api_delegate> efl_gfx_stack_layer_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_layer_set_api_delegate>(_Module, "efl_gfx_stack_layer_set");
2193      private static void layer_set(System.IntPtr obj, System.IntPtr pd,  short l)
2194     {
2195         Eina.Log.Debug("function efl_gfx_stack_layer_set was called");
2196         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2197         if(wrapper != null) {
2198
2199             try {
2200                 ((Node)wrapper).SetLayer( l);
2201             } catch (Exception e) {
2202                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2203                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2204             }
2205                                 } else {
2206             efl_gfx_stack_layer_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  l);
2207         }
2208     }
2209     private static efl_gfx_stack_layer_set_delegate efl_gfx_stack_layer_set_static_delegate;
2210
2211
2212     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.IStack efl_gfx_stack_below_get_delegate(System.IntPtr obj, System.IntPtr pd);
2213
2214
2215     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.IStack efl_gfx_stack_below_get_api_delegate(System.IntPtr obj);
2216      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_below_get_api_delegate> efl_gfx_stack_below_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_below_get_api_delegate>(_Module, "efl_gfx_stack_below_get");
2217      private static Efl.Gfx.IStack below_get(System.IntPtr obj, System.IntPtr pd)
2218     {
2219         Eina.Log.Debug("function efl_gfx_stack_below_get was called");
2220         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2221         if(wrapper != null) {
2222                         Efl.Gfx.IStack _ret_var = default(Efl.Gfx.IStack);
2223             try {
2224                 _ret_var = ((Node)wrapper).GetBelow();
2225             } catch (Exception e) {
2226                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2227                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2228             }
2229         return _ret_var;
2230         } else {
2231             return efl_gfx_stack_below_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2232         }
2233     }
2234     private static efl_gfx_stack_below_get_delegate efl_gfx_stack_below_get_static_delegate;
2235
2236
2237     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.IStack efl_gfx_stack_above_get_delegate(System.IntPtr obj, System.IntPtr pd);
2238
2239
2240     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.IStack efl_gfx_stack_above_get_api_delegate(System.IntPtr obj);
2241      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_above_get_api_delegate> efl_gfx_stack_above_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_above_get_api_delegate>(_Module, "efl_gfx_stack_above_get");
2242      private static Efl.Gfx.IStack above_get(System.IntPtr obj, System.IntPtr pd)
2243     {
2244         Eina.Log.Debug("function efl_gfx_stack_above_get was called");
2245         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2246         if(wrapper != null) {
2247                         Efl.Gfx.IStack _ret_var = default(Efl.Gfx.IStack);
2248             try {
2249                 _ret_var = ((Node)wrapper).GetAbove();
2250             } catch (Exception e) {
2251                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2252                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2253             }
2254         return _ret_var;
2255         } else {
2256             return efl_gfx_stack_above_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2257         }
2258     }
2259     private static efl_gfx_stack_above_get_delegate efl_gfx_stack_above_get_static_delegate;
2260
2261
2262      private delegate void efl_gfx_stack_below_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IStack below);
2263
2264
2265      public delegate void efl_gfx_stack_below_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IStack below);
2266      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_below_api_delegate> efl_gfx_stack_below_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_below_api_delegate>(_Module, "efl_gfx_stack_below");
2267      private static void stack_below(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IStack below)
2268     {
2269         Eina.Log.Debug("function efl_gfx_stack_below was called");
2270         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2271         if(wrapper != null) {
2272
2273             try {
2274                 ((Node)wrapper).StackBelow( below);
2275             } catch (Exception e) {
2276                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2277                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2278             }
2279                                 } else {
2280             efl_gfx_stack_below_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  below);
2281         }
2282     }
2283     private static efl_gfx_stack_below_delegate efl_gfx_stack_below_static_delegate;
2284
2285
2286      private delegate void efl_gfx_stack_raise_to_top_delegate(System.IntPtr obj, System.IntPtr pd);
2287
2288
2289      public delegate void efl_gfx_stack_raise_to_top_api_delegate(System.IntPtr obj);
2290      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_raise_to_top_api_delegate> efl_gfx_stack_raise_to_top_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_raise_to_top_api_delegate>(_Module, "efl_gfx_stack_raise_to_top");
2291      private static void raise_to_top(System.IntPtr obj, System.IntPtr pd)
2292     {
2293         Eina.Log.Debug("function efl_gfx_stack_raise_to_top was called");
2294         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2295         if(wrapper != null) {
2296
2297             try {
2298                 ((Node)wrapper).RaiseToTop();
2299             } catch (Exception e) {
2300                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2301                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2302             }
2303                 } else {
2304             efl_gfx_stack_raise_to_top_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2305         }
2306     }
2307     private static efl_gfx_stack_raise_to_top_delegate efl_gfx_stack_raise_to_top_static_delegate;
2308
2309
2310      private delegate void efl_gfx_stack_above_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IStack above);
2311
2312
2313      public delegate void efl_gfx_stack_above_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IStackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IStack above);
2314      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_above_api_delegate> efl_gfx_stack_above_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_above_api_delegate>(_Module, "efl_gfx_stack_above");
2315      private static void stack_above(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IStack above)
2316     {
2317         Eina.Log.Debug("function efl_gfx_stack_above was called");
2318         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2319         if(wrapper != null) {
2320
2321             try {
2322                 ((Node)wrapper).StackAbove( above);
2323             } catch (Exception e) {
2324                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2325                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2326             }
2327                                 } else {
2328             efl_gfx_stack_above_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  above);
2329         }
2330     }
2331     private static efl_gfx_stack_above_delegate efl_gfx_stack_above_static_delegate;
2332
2333
2334      private delegate void efl_gfx_stack_lower_to_bottom_delegate(System.IntPtr obj, System.IntPtr pd);
2335
2336
2337      public delegate void efl_gfx_stack_lower_to_bottom_api_delegate(System.IntPtr obj);
2338      public static Efl.Eo.FunctionWrapper<efl_gfx_stack_lower_to_bottom_api_delegate> efl_gfx_stack_lower_to_bottom_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_stack_lower_to_bottom_api_delegate>(_Module, "efl_gfx_stack_lower_to_bottom");
2339      private static void lower_to_bottom(System.IntPtr obj, System.IntPtr pd)
2340     {
2341         Eina.Log.Debug("function efl_gfx_stack_lower_to_bottom was called");
2342         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2343         if(wrapper != null) {
2344
2345             try {
2346                 ((Node)wrapper).LowerToBottom();
2347             } catch (Exception e) {
2348                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2349                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2350             }
2351                 } else {
2352             efl_gfx_stack_lower_to_bottom_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2353         }
2354     }
2355     private static efl_gfx_stack_lower_to_bottom_delegate efl_gfx_stack_lower_to_bottom_static_delegate;
2356 }
2357 } } }