internals/src/EflSharp/EflSharp/efl_access_component.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 Access {
   8 /// <summary>AT-SPI component mixin</summary>
   9 [ComponentNativeInherit]
  10 public interface Component :
  11    Efl.Gfx.Entity ,
  12    Efl.Gfx.Stack ,
  13    Efl.Eo.IWrapper, IDisposable
  14 {
  15    /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
  16 /// <returns>Z order of component</returns>
  17  int GetZOrder();
  18    /// <summary>Geometry of accessible widget.</summary>
  19 /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
  20 /// <returns>The geometry.</returns>
  21 Eina.Rect GetExtents( bool screen_coords);
  22    /// <summary>Geometry of accessible widget.</summary>
  23 /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
  24 /// <param name="rect">The geometry.</param>
  25 /// <returns><c>true</c> if geometry was set, <c>false</c> otherwise</returns>
  26 bool SetExtents( bool screen_coords,  Eina.Rect rect);
  27    /// <summary>Position of accessible widget.</summary>
  28 /// <param name="x">X coordinate</param>
  29 /// <param name="y">Y coordinate</param>
  30 /// <returns></returns>
  31  void GetScreenPosition( out  int x,  out  int y);
  32    /// <summary>Position of accessible widget.</summary>
  33 /// <param name="x">X coordinate</param>
  34 /// <param name="y">Y coordinate</param>
  35 /// <returns><c>true</c> if position was set, <c>false</c> otherwise</returns>
  36 bool SetScreenPosition(  int x,   int y);
  37    /// <summary>Gets position of socket offset.</summary>
  38 /// <param name="x"></param>
  39 /// <param name="y"></param>
  40 /// <returns></returns>
  41  void GetSocketOffset( out  int x,  out  int y);
  42    /// <summary>Sets position of socket offset.</summary>
  43 /// <param name="x"></param>
  44 /// <param name="y"></param>
  45 /// <returns></returns>
  46  void SetSocketOffset(  int x,   int y);
  47    /// <summary>Contains accessible widget</summary>
  48 /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
  49 /// <param name="x">X coordinate</param>
  50 /// <param name="y">Y coordinate</param>
  51 /// <returns><c>true</c> if params have been set, <c>false</c> otherwise</returns>
  52 bool Contains( bool screen_coords,   int x,   int y);
  53    /// <summary>Focuses accessible widget.</summary>
  54 /// <returns><c>true</c> if focus grab focus succeed, <c>false</c> otherwise.</returns>
  55 bool GrabFocus();
  56    /// <summary>Gets top component object occupying space at given coordinates.</summary>
  57 /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
  58 /// <param name="x">X coordinate</param>
  59 /// <param name="y">Y coordinate</param>
  60 /// <returns>Top component object at given coordinate</returns>
  61 Efl.Object GetAccessibleAtPoint( bool screen_coords,   int x,   int y);
  62    /// <summary>Highlights accessible widget. returns true if highlight grab has successed, false otherwise.
  63 /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
  64 /// <returns></returns>
  65 bool GrabHighlight();
  66    /// <summary>Clears highlight of accessible widget. returns true if clear has successed, false otherwise.
  67 /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
  68 /// <returns></returns>
  69 bool ClearHighlight();
  70                                        /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
  71 /// <value>Z order of component</value>
  72     int ZOrder {
  73       get ;
  74    }
  75 }
  76 /// <summary>AT-SPI component mixin</summary>
  77 sealed public class ComponentConcrete :
  78
  79 Component
  80    , Efl.Gfx.Entity, Efl.Gfx.Stack
  81 {
  82    ///<summary>Pointer to the native class description.</summary>
  83    public System.IntPtr NativeClass {
  84       get {
  85          if (((object)this).GetType() == typeof (ComponentConcrete))
  86             return Efl.Access.ComponentNativeInherit.GetEflClassStatic();
  87          else
  88             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  89       }
  90    }
  91    private EventHandlerList eventHandlers = new EventHandlerList();
  92    private  System.IntPtr handle;
  93    ///<summary>Pointer to the native instance.</summary>
  94    public System.IntPtr NativeHandle {
  95       get { return handle; }
  96    }
  97    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  98       efl_access_component_mixin_get();
  99    ///<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>
 100    public ComponentConcrete(System.IntPtr raw)
 101    {
 102       handle = raw;
 103       register_event_proxies();
 104    }
 105    ///<summary>Destructor.</summary>
 106    ~ComponentConcrete()
 107    {
 108       Dispose(false);
 109    }
 110    ///<summary>Releases the underlying native instance.</summary>
 111    void Dispose(bool disposing)
 112    {
 113       if (handle != System.IntPtr.Zero) {
 114          Efl.Eo.Globals.efl_unref(handle);
 115          handle = System.IntPtr.Zero;
 116       }
 117    }
 118    ///<summary>Releases the underlying native instance.</summary>
 119    public void Dispose()
 120    {
 121       Dispose(true);
 122       GC.SuppressFinalize(this);
 123    }
 124    ///<summary>Casts obj into an instance of this type.</summary>
 125    public static ComponentConcrete static_cast(Efl.Object obj)
 126    {
 127       if (obj == null)
 128          throw new System.ArgumentNullException("obj");
 129       return new ComponentConcrete(obj.NativeHandle);
 130    }
 131    ///<summary>Verifies if the given object is equal to this one.</summary>
 132    public override bool Equals(object obj)
 133    {
 134       var other = obj as Efl.Object;
 135       if (other == null)
 136          return false;
 137       return this.NativeHandle == other.NativeHandle;
 138    }
 139    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 140    public override int GetHashCode()
 141    {
 142       return this.NativeHandle.ToInt32();
 143    }
 144    ///<summary>Turns the native pointer into a string representation.</summary>
 145    public override String ToString()
 146    {
 147       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 148    }
 149    private readonly object eventLock = new object();
 150    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 151    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 152       int event_count = 0;
 153       if (!event_cb_count.TryGetValue(key, out event_count))
 154          event_cb_count[key] = event_count;
 155       if (event_count == 0) {
 156          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 157          if (desc == IntPtr.Zero) {
 158             Eina.Log.Error($"Failed to get native event {key}");
 159             return false;
 160          }
 161           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 162          if (!result) {
 163             Eina.Log.Error($"Failed to add event proxy for event {key}");
 164             return false;
 165          }
 166          Eina.Error.RaiseIfUnhandledException();
 167       }
 168       event_cb_count[key]++;
 169       return true;
 170    }
 171    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 172       int event_count = 0;
 173       if (!event_cb_count.TryGetValue(key, out event_count))
 174          event_cb_count[key] = event_count;
 175       if (event_count == 1) {
 176          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 177          if (desc == IntPtr.Zero) {
 178             Eina.Log.Error($"Failed to get native event {key}");
 179             return false;
 180          }
 181          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 182          if (!result) {
 183             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 184             return false;
 185          }
 186          Eina.Error.RaiseIfUnhandledException();
 187       } else if (event_count == 0) {
 188          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 189          return false;
 190       }
 191       event_cb_count[key]--;
 192       return true;
 193    }
 194 private static object VisibilityChangedEvtKey = new object();
 195    /// <summary>Object&apos;s visibility state changed, the event value is the new state.</summary>
 196    public event EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args> VisibilityChangedEvt
 197    {
 198       add {
 199          lock (eventLock) {
 200             string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
 201             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_VisibilityChangedEvt_delegate)) {
 202                eventHandlers.AddHandler(VisibilityChangedEvtKey , value);
 203             } else
 204                Eina.Log.Error($"Error adding proxy for event {key}");
 205          }
 206       }
 207       remove {
 208          lock (eventLock) {
 209             string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
 210             if (remove_cpp_event_handler(key, this.evt_VisibilityChangedEvt_delegate)) {
 211                eventHandlers.RemoveHandler(VisibilityChangedEvtKey , value);
 212             } else
 213                Eina.Log.Error($"Error removing proxy for event {key}");
 214          }
 215       }
 216    }
 217    ///<summary>Method to raise event VisibilityChangedEvt.</summary>
 218    public void On_VisibilityChangedEvt(Efl.Gfx.EntityVisibilityChangedEvt_Args e)
 219    {
 220       EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args> evt;
 221       lock (eventLock) {
 222       evt = (EventHandler<Efl.Gfx.EntityVisibilityChangedEvt_Args>)eventHandlers[VisibilityChangedEvtKey];
 223       }
 224       evt?.Invoke(this, e);
 225    }
 226    Efl.EventCb evt_VisibilityChangedEvt_delegate;
 227    private void on_VisibilityChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 228    {
 229       Efl.Gfx.EntityVisibilityChangedEvt_Args args = new Efl.Gfx.EntityVisibilityChangedEvt_Args();
 230       args.arg = evt.Info != IntPtr.Zero;
 231       try {
 232          On_VisibilityChangedEvt(args);
 233       } catch (Exception e) {
 234          Eina.Log.Error(e.ToString());
 235          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 236       }
 237    }
 238
 239 private static object PositionChangedEvtKey = new object();
 240    /// <summary>Object was moved, its position during the event is the new one.</summary>
 241    public event EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args> PositionChangedEvt
 242    {
 243       add {
 244          lock (eventLock) {
 245             string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 246             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_PositionChangedEvt_delegate)) {
 247                eventHandlers.AddHandler(PositionChangedEvtKey , value);
 248             } else
 249                Eina.Log.Error($"Error adding proxy for event {key}");
 250          }
 251       }
 252       remove {
 253          lock (eventLock) {
 254             string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
 255             if (remove_cpp_event_handler(key, this.evt_PositionChangedEvt_delegate)) {
 256                eventHandlers.RemoveHandler(PositionChangedEvtKey , value);
 257             } else
 258                Eina.Log.Error($"Error removing proxy for event {key}");
 259          }
 260       }
 261    }
 262    ///<summary>Method to raise event PositionChangedEvt.</summary>
 263    public void On_PositionChangedEvt(Efl.Gfx.EntityPositionChangedEvt_Args e)
 264    {
 265       EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args> evt;
 266       lock (eventLock) {
 267       evt = (EventHandler<Efl.Gfx.EntityPositionChangedEvt_Args>)eventHandlers[PositionChangedEvtKey];
 268       }
 269       evt?.Invoke(this, e);
 270    }
 271    Efl.EventCb evt_PositionChangedEvt_delegate;
 272    private void on_PositionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 273    {
 274       Efl.Gfx.EntityPositionChangedEvt_Args args = new Efl.Gfx.EntityPositionChangedEvt_Args();
 275       args.arg =  evt.Info;;
 276       try {
 277          On_PositionChangedEvt(args);
 278       } catch (Exception e) {
 279          Eina.Log.Error(e.ToString());
 280          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 281       }
 282    }
 283
 284 private static object SizeChangedEvtKey = new object();
 285    /// <summary>Object was resized, its size during the event is the new one.</summary>
 286    public event EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args> SizeChangedEvt
 287    {
 288       add {
 289          lock (eventLock) {
 290             string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 291             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SizeChangedEvt_delegate)) {
 292                eventHandlers.AddHandler(SizeChangedEvtKey , value);
 293             } else
 294                Eina.Log.Error($"Error adding proxy for event {key}");
 295          }
 296       }
 297       remove {
 298          lock (eventLock) {
 299             string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
 300             if (remove_cpp_event_handler(key, this.evt_SizeChangedEvt_delegate)) {
 301                eventHandlers.RemoveHandler(SizeChangedEvtKey , value);
 302             } else
 303                Eina.Log.Error($"Error removing proxy for event {key}");
 304          }
 305       }
 306    }
 307    ///<summary>Method to raise event SizeChangedEvt.</summary>
 308    public void On_SizeChangedEvt(Efl.Gfx.EntitySizeChangedEvt_Args e)
 309    {
 310       EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args> evt;
 311       lock (eventLock) {
 312       evt = (EventHandler<Efl.Gfx.EntitySizeChangedEvt_Args>)eventHandlers[SizeChangedEvtKey];
 313       }
 314       evt?.Invoke(this, e);
 315    }
 316    Efl.EventCb evt_SizeChangedEvt_delegate;
 317    private void on_SizeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 318    {
 319       Efl.Gfx.EntitySizeChangedEvt_Args args = new Efl.Gfx.EntitySizeChangedEvt_Args();
 320       args.arg =  evt.Info;;
 321       try {
 322          On_SizeChangedEvt(args);
 323       } catch (Exception e) {
 324          Eina.Log.Error(e.ToString());
 325          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 326       }
 327    }
 328
 329 private static object StackingChangedEvtKey = new object();
 330    /// <summary>Object stacking was changed.</summary>
 331    public event EventHandler StackingChangedEvt
 332    {
 333       add {
 334          lock (eventLock) {
 335             string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
 336             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_StackingChangedEvt_delegate)) {
 337                eventHandlers.AddHandler(StackingChangedEvtKey , value);
 338             } else
 339                Eina.Log.Error($"Error adding proxy for event {key}");
 340          }
 341       }
 342       remove {
 343          lock (eventLock) {
 344             string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
 345             if (remove_cpp_event_handler(key, this.evt_StackingChangedEvt_delegate)) {
 346                eventHandlers.RemoveHandler(StackingChangedEvtKey , value);
 347             } else
 348                Eina.Log.Error($"Error removing proxy for event {key}");
 349          }
 350       }
 351    }
 352    ///<summary>Method to raise event StackingChangedEvt.</summary>
 353    public void On_StackingChangedEvt(EventArgs e)
 354    {
 355       EventHandler evt;
 356       lock (eventLock) {
 357       evt = (EventHandler)eventHandlers[StackingChangedEvtKey];
 358       }
 359       evt?.Invoke(this, e);
 360    }
 361    Efl.EventCb evt_StackingChangedEvt_delegate;
 362    private void on_StackingChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 363    {
 364       EventArgs args = EventArgs.Empty;
 365       try {
 366          On_StackingChangedEvt(args);
 367       } catch (Exception e) {
 368          Eina.Log.Error(e.ToString());
 369          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 370       }
 371    }
 372
 373     void register_event_proxies()
 374    {
 375       evt_VisibilityChangedEvt_delegate = new Efl.EventCb(on_VisibilityChangedEvt_NativeCallback);
 376       evt_PositionChangedEvt_delegate = new Efl.EventCb(on_PositionChangedEvt_NativeCallback);
 377       evt_SizeChangedEvt_delegate = new Efl.EventCb(on_SizeChangedEvt_NativeCallback);
 378       evt_StackingChangedEvt_delegate = new Efl.EventCb(on_StackingChangedEvt_NativeCallback);
 379    }
 380    /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
 381    /// <returns>Z order of component</returns>
 382    public  int GetZOrder() {
 383        var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_z_order_get_ptr.Value.Delegate(this.NativeHandle);
 384       Eina.Error.RaiseIfUnhandledException();
 385       return _ret_var;
 386  }
 387    /// <summary>Geometry of accessible widget.</summary>
 388    /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
 389    /// <returns>The geometry.</returns>
 390    public Eina.Rect GetExtents( bool screen_coords) {
 391                          var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_extents_get_ptr.Value.Delegate(this.NativeHandle, screen_coords);
 392       Eina.Error.RaiseIfUnhandledException();
 393                   return Eina.Rect_StructConversion.ToManaged(_ret_var);
 394  }
 395    /// <summary>Geometry of accessible widget.</summary>
 396    /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
 397    /// <param name="rect">The geometry.</param>
 398    /// <returns><c>true</c> if geometry was set, <c>false</c> otherwise</returns>
 399    public bool SetExtents( bool screen_coords,  Eina.Rect rect) {
 400              var _in_rect = Eina.Rect_StructConversion.ToInternal(rect);
 401                               var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_extents_set_ptr.Value.Delegate(this.NativeHandle, screen_coords,  _in_rect);
 402       Eina.Error.RaiseIfUnhandledException();
 403                               return _ret_var;
 404  }
 405    /// <summary>Position of accessible widget.</summary>
 406    /// <param name="x">X coordinate</param>
 407    /// <param name="y">Y coordinate</param>
 408    /// <returns></returns>
 409    public  void GetScreenPosition( out  int x,  out  int y) {
 410                                            Efl.Access.ComponentNativeInherit.efl_access_component_screen_position_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 411       Eina.Error.RaiseIfUnhandledException();
 412                                }
 413    /// <summary>Position of accessible widget.</summary>
 414    /// <param name="x">X coordinate</param>
 415    /// <param name="y">Y coordinate</param>
 416    /// <returns><c>true</c> if position was set, <c>false</c> otherwise</returns>
 417    public bool SetScreenPosition(  int x,   int y) {
 418                                            var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_screen_position_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 419       Eina.Error.RaiseIfUnhandledException();
 420                               return _ret_var;
 421  }
 422    /// <summary>Gets position of socket offset.</summary>
 423    /// <param name="x"></param>
 424    /// <param name="y"></param>
 425    /// <returns></returns>
 426    public  void GetSocketOffset( out  int x,  out  int y) {
 427                                            Efl.Access.ComponentNativeInherit.efl_access_component_socket_offset_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 428       Eina.Error.RaiseIfUnhandledException();
 429                                }
 430    /// <summary>Sets position of socket offset.</summary>
 431    /// <param name="x"></param>
 432    /// <param name="y"></param>
 433    /// <returns></returns>
 434    public  void SetSocketOffset(  int x,   int y) {
 435                                            Efl.Access.ComponentNativeInherit.efl_access_component_socket_offset_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 436       Eina.Error.RaiseIfUnhandledException();
 437                                }
 438    /// <summary>Contains accessible widget</summary>
 439    /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
 440    /// <param name="x">X coordinate</param>
 441    /// <param name="y">Y coordinate</param>
 442    /// <returns><c>true</c> if params have been set, <c>false</c> otherwise</returns>
 443    public bool Contains( bool screen_coords,   int x,   int y) {
 444                                                              var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_contains_ptr.Value.Delegate(this.NativeHandle, screen_coords,  x,  y);
 445       Eina.Error.RaiseIfUnhandledException();
 446                                           return _ret_var;
 447  }
 448    /// <summary>Focuses accessible widget.</summary>
 449    /// <returns><c>true</c> if focus grab focus succeed, <c>false</c> otherwise.</returns>
 450    public bool GrabFocus() {
 451        var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_focus_grab_ptr.Value.Delegate(this.NativeHandle);
 452       Eina.Error.RaiseIfUnhandledException();
 453       return _ret_var;
 454  }
 455    /// <summary>Gets top component object occupying space at given coordinates.</summary>
 456    /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
 457    /// <param name="x">X coordinate</param>
 458    /// <param name="y">Y coordinate</param>
 459    /// <returns>Top component object at given coordinate</returns>
 460    public Efl.Object GetAccessibleAtPoint( bool screen_coords,   int x,   int y) {
 461                                                              var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_accessible_at_point_get_ptr.Value.Delegate(this.NativeHandle, screen_coords,  x,  y);
 462       Eina.Error.RaiseIfUnhandledException();
 463                                           return _ret_var;
 464  }
 465    /// <summary>Highlights accessible widget. returns true if highlight grab has successed, false otherwise.
 466    /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
 467    /// <returns></returns>
 468    public bool GrabHighlight() {
 469        var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_highlight_grab_ptr.Value.Delegate(this.NativeHandle);
 470       Eina.Error.RaiseIfUnhandledException();
 471       return _ret_var;
 472  }
 473    /// <summary>Clears highlight of accessible widget. returns true if clear has successed, false otherwise.
 474    /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
 475    /// <returns></returns>
 476    public bool ClearHighlight() {
 477        var _ret_var = Efl.Access.ComponentNativeInherit.efl_access_component_highlight_clear_ptr.Value.Delegate(this.NativeHandle);
 478       Eina.Error.RaiseIfUnhandledException();
 479       return _ret_var;
 480  }
 481    /// <summary>Retrieves the position of the given canvas object.</summary>
 482    /// <returns>A 2D coordinate in pixel units.</returns>
 483    public Eina.Position2D GetPosition() {
 484        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_position_get_ptr.Value.Delegate(this.NativeHandle);
 485       Eina.Error.RaiseIfUnhandledException();
 486       return Eina.Position2D_StructConversion.ToManaged(_ret_var);
 487  }
 488    /// <summary>Moves the given canvas object to the given location inside its canvas&apos; viewport. If unchanged this call may be entirely skipped, but if changed this will trigger move events, as well as potential pointer,in or pointer,out events.</summary>
 489    /// <param name="pos">A 2D coordinate in pixel units.</param>
 490    /// <returns></returns>
 491    public  void SetPosition( Eina.Position2D pos) {
 492        var _in_pos = Eina.Position2D_StructConversion.ToInternal(pos);
 493                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_position_set_ptr.Value.Delegate(this.NativeHandle, _in_pos);
 494       Eina.Error.RaiseIfUnhandledException();
 495                    }
 496    /// <summary>Retrieves the (rectangular) size of the given Evas object.</summary>
 497    /// <returns>A 2D size in pixel units.</returns>
 498    public Eina.Size2D GetSize() {
 499        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_size_get_ptr.Value.Delegate(this.NativeHandle);
 500       Eina.Error.RaiseIfUnhandledException();
 501       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 502  }
 503    /// <summary>Changes the size of the given object.
 504    /// Note that setting the actual size of an object might be the job of its container, so this function might have no effect. Look at <see cref="Efl.Gfx.Hint"/> instead, when manipulating widgets.</summary>
 505    /// <param name="size">A 2D size in pixel units.</param>
 506    /// <returns></returns>
 507    public  void SetSize( Eina.Size2D size) {
 508        var _in_size = Eina.Size2D_StructConversion.ToInternal(size);
 509                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_size_set_ptr.Value.Delegate(this.NativeHandle, _in_size);
 510       Eina.Error.RaiseIfUnhandledException();
 511                    }
 512    /// <summary>Rectangular geometry that combines both position and size.</summary>
 513    /// <returns>The X,Y position and W,H size, in pixels.</returns>
 514    public Eina.Rect GetGeometry() {
 515        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_geometry_get_ptr.Value.Delegate(this.NativeHandle);
 516       Eina.Error.RaiseIfUnhandledException();
 517       return Eina.Rect_StructConversion.ToManaged(_ret_var);
 518  }
 519    /// <summary>Rectangular geometry that combines both position and size.</summary>
 520    /// <param name="rect">The X,Y position and W,H size, in pixels.</param>
 521    /// <returns></returns>
 522    public  void SetGeometry( Eina.Rect rect) {
 523        var _in_rect = Eina.Rect_StructConversion.ToInternal(rect);
 524                   Efl.Gfx.EntityNativeInherit.efl_gfx_entity_geometry_set_ptr.Value.Delegate(this.NativeHandle, _in_rect);
 525       Eina.Error.RaiseIfUnhandledException();
 526                    }
 527    /// <summary>Retrieves whether or not the given canvas object is visible.</summary>
 528    /// <returns><c>true</c> if to make the object visible, <c>false</c> otherwise</returns>
 529    public bool GetVisible() {
 530        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_visible_get_ptr.Value.Delegate(this.NativeHandle);
 531       Eina.Error.RaiseIfUnhandledException();
 532       return _ret_var;
 533  }
 534    /// <summary>Shows or hides this object.</summary>
 535    /// <param name="v"><c>true</c> if to make the object visible, <c>false</c> otherwise</param>
 536    /// <returns></returns>
 537    public  void SetVisible( bool v) {
 538                          Efl.Gfx.EntityNativeInherit.efl_gfx_entity_visible_set_ptr.Value.Delegate(this.NativeHandle, v);
 539       Eina.Error.RaiseIfUnhandledException();
 540                    }
 541    /// <summary>Gets an object&apos;s scaling factor.</summary>
 542    /// <returns>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</returns>
 543    public double GetScale() {
 544        var _ret_var = Efl.Gfx.EntityNativeInherit.efl_gfx_entity_scale_get_ptr.Value.Delegate(this.NativeHandle);
 545       Eina.Error.RaiseIfUnhandledException();
 546       return _ret_var;
 547  }
 548    /// <summary>Sets the scaling factor of an object.</summary>
 549    /// <param name="scale">The scaling factor (the default value is 0.0, meaning individual scaling is not set)</param>
 550    /// <returns></returns>
 551    public  void SetScale( double scale) {
 552                          Efl.Gfx.EntityNativeInherit.efl_gfx_entity_scale_set_ptr.Value.Delegate(this.NativeHandle, scale);
 553       Eina.Error.RaiseIfUnhandledException();
 554                    }
 555    /// <summary>Retrieves the layer of its canvas that the given object is part of.
 556    /// See also <see cref="Efl.Gfx.Stack.SetLayer"/></summary>
 557    /// <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>
 558    public  short GetLayer() {
 559        var _ret_var = Efl.Gfx.StackNativeInherit.efl_gfx_stack_layer_get_ptr.Value.Delegate(this.NativeHandle);
 560       Eina.Error.RaiseIfUnhandledException();
 561       return _ret_var;
 562  }
 563    /// <summary>Sets the layer of its canvas that the given object will be part of.
 564    /// 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.
 565    ///
 566    /// This is a low-level function, which you&apos;d be using when something should be always on top, for example.
 567    ///
 568    /// 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.
 569    ///
 570    /// See also <see cref="Efl.Gfx.Stack.GetLayer"/></summary>
 571    /// <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>
 572    /// <returns></returns>
 573    public  void SetLayer(  short l) {
 574                          Efl.Gfx.StackNativeInherit.efl_gfx_stack_layer_set_ptr.Value.Delegate(this.NativeHandle, l);
 575       Eina.Error.RaiseIfUnhandledException();
 576                    }
 577    /// <summary>Get the Evas object stacked right below <c>obj</c>
 578    /// This function will traverse layers in its search, if there are objects on layers below the one <c>obj</c> is placed at.
 579    ///
 580    /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.GetBelow"/></summary>
 581    /// <returns>The <see cref="Efl.Gfx.Stack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</returns>
 582    public Efl.Gfx.Stack GetBelow() {
 583        var _ret_var = Efl.Gfx.StackNativeInherit.efl_gfx_stack_below_get_ptr.Value.Delegate(this.NativeHandle);
 584       Eina.Error.RaiseIfUnhandledException();
 585       return _ret_var;
 586  }
 587    /// <summary>Get the Evas object stacked right above <c>obj</c>
 588    /// This function will traverse layers in its search, if there are objects on layers above the one <c>obj</c> is placed at.
 589    ///
 590    /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.GetBelow"/></summary>
 591    /// <returns>The <see cref="Efl.Gfx.Stack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</returns>
 592    public Efl.Gfx.Stack GetAbove() {
 593        var _ret_var = Efl.Gfx.StackNativeInherit.efl_gfx_stack_above_get_ptr.Value.Delegate(this.NativeHandle);
 594       Eina.Error.RaiseIfUnhandledException();
 595       return _ret_var;
 596  }
 597    /// <summary>Stack <c>obj</c> immediately <c>below</c>
 598    /// 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.
 599    ///
 600    /// Its intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).
 601    ///
 602    /// 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.
 603    ///
 604    /// Similarly, if <c>obj</c> is not a member of a smart object, <c>below</c> must not be either.
 605    ///
 606    /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.StackBelow"/></summary>
 607    /// <param name="below">The object below which to stack</param>
 608    /// <returns></returns>
 609    public  void StackBelow( Efl.Gfx.Stack below) {
 610                          Efl.Gfx.StackNativeInherit.efl_gfx_stack_below_ptr.Value.Delegate(this.NativeHandle, below);
 611       Eina.Error.RaiseIfUnhandledException();
 612                    }
 613    /// <summary>Raise <c>obj</c> to the top of its layer.
 614    /// <c>obj</c> will, then, be the highest one in the layer it belongs to. Object on other layers won&apos;t get touched.
 615    ///
 616    /// See also <see cref="Efl.Gfx.Stack.StackAbove"/>, <see cref="Efl.Gfx.Stack.StackBelow"/> and <see cref="Efl.Gfx.Stack.LowerToBottom"/></summary>
 617    /// <returns></returns>
 618    public  void RaiseToTop() {
 619        Efl.Gfx.StackNativeInherit.efl_gfx_stack_raise_to_top_ptr.Value.Delegate(this.NativeHandle);
 620       Eina.Error.RaiseIfUnhandledException();
 621        }
 622    /// <summary>Stack <c>obj</c> immediately <c>above</c>
 623    /// 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.
 624    ///
 625    /// Its intended to be used with objects belonging to the same layer in a given canvas, otherwise it will fail (and accomplish nothing).
 626    ///
 627    /// 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.
 628    ///
 629    /// Similarly, if <c>obj</c> is not a member of a smart object, <c>above</c> must not be either.
 630    ///
 631    /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.StackBelow"/></summary>
 632    /// <param name="above">The object above which to stack</param>
 633    /// <returns></returns>
 634    public  void StackAbove( Efl.Gfx.Stack above) {
 635                          Efl.Gfx.StackNativeInherit.efl_gfx_stack_above_ptr.Value.Delegate(this.NativeHandle, above);
 636       Eina.Error.RaiseIfUnhandledException();
 637                    }
 638    /// <summary>Lower <c>obj</c> to the bottom of its layer.
 639    /// <c>obj</c> will, then, be the lowest one in the layer it belongs to. Objects on other layers won&apos;t get touched.
 640    ///
 641    /// See also <see cref="Efl.Gfx.Stack.StackAbove"/>, <see cref="Efl.Gfx.Stack.StackBelow"/> and <see cref="Efl.Gfx.Stack.RaiseToTop"/></summary>
 642    /// <returns></returns>
 643    public  void LowerToBottom() {
 644        Efl.Gfx.StackNativeInherit.efl_gfx_stack_lower_to_bottom_ptr.Value.Delegate(this.NativeHandle);
 645       Eina.Error.RaiseIfUnhandledException();
 646        }
 647    /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
 648 /// <value>Z order of component</value>
 649    public  int ZOrder {
 650       get { return GetZOrder(); }
 651    }
 652    /// <summary>The 2D position of a canvas object.
 653 /// The position is absolute, in pixels, relative to the top-left corner of the window, within its border decorations (application space).</summary>
 654 /// <value>A 2D coordinate in pixel units.</value>
 655    public Eina.Position2D Position {
 656       get { return GetPosition(); }
 657       set { SetPosition( value); }
 658    }
 659    /// <summary>The 2D size of a canvas object.</summary>
 660 /// <value>A 2D size in pixel units.</value>
 661    public Eina.Size2D Size {
 662       get { return GetSize(); }
 663       set { SetSize( value); }
 664    }
 665    /// <summary>Rectangular geometry that combines both position and size.</summary>
 666 /// <value>The X,Y position and W,H size, in pixels.</value>
 667    public Eina.Rect Geometry {
 668       get { return GetGeometry(); }
 669       set { SetGeometry( value); }
 670    }
 671    /// <summary>The visibility of a canvas object.
 672 /// All canvas objects will become visible by default just before render. This means that it is not required to call <see cref="Efl.Gfx.Entity.SetVisible"/> after creating an object unless you want to create it without showing it. Note that this behavior is new since 1.21, and only applies to canvas objects created with the EO API (i.e. not the legacy C-only API). Other types of Gfx objects may or may not be visible by default.
 673 ///
 674 /// Note that many other parameters can prevent a visible object from actually being &quot;visible&quot; on screen. For instance if its color is fully transparent, or its parent is hidden, or it is clipped out, etc...</summary>
 675 /// <value><c>true</c> if to make the object visible, <c>false</c> otherwise</value>
 676    public bool Visible {
 677       get { return GetVisible(); }
 678       set { SetVisible( value); }
 679    }
 680    /// <summary>The scaling factor of an object.
 681 /// 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.
 682 ///
 683 /// Warning: In Edje, only parts which, at EDC level, had the &quot;scale&quot; property set to 1, will be affected by this function. Check the complete &quot;syntax reference&quot; for EDC files.</summary>
 684 /// <value>The scaling factor (the default value is 0.0, meaning individual scaling is not set)</value>
 685    public double Scale {
 686       get { return GetScale(); }
 687       set { SetScale( value); }
 688    }
 689    /// <summary>Retrieves the layer of its canvas that the given object is part of.
 690 /// See also <see cref="Efl.Gfx.Stack.SetLayer"/></summary>
 691 /// <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>
 692    public  short Layer {
 693       get { return GetLayer(); }
 694       set { SetLayer( value); }
 695    }
 696    /// <summary>Get the Evas object stacked right below <c>obj</c>
 697 /// This function will traverse layers in its search, if there are objects on layers below the one <c>obj</c> is placed at.
 698 ///
 699 /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.GetBelow"/></summary>
 700 /// <value>The <see cref="Efl.Gfx.Stack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</value>
 701    public Efl.Gfx.Stack Below {
 702       get { return GetBelow(); }
 703    }
 704    /// <summary>Get the Evas object stacked right above <c>obj</c>
 705 /// This function will traverse layers in its search, if there are objects on layers above the one <c>obj</c> is placed at.
 706 ///
 707 /// See also <see cref="Efl.Gfx.Stack.GetLayer"/>, <see cref="Efl.Gfx.Stack.SetLayer"/> and <see cref="Efl.Gfx.Stack.GetBelow"/></summary>
 708 /// <value>The <see cref="Efl.Gfx.Stack"/> object directly below <c>obj</c>, if any, or <c>null</c>, if none.</value>
 709    public Efl.Gfx.Stack Above {
 710       get { return GetAbove(); }
 711    }
 712 }
 713 public class ComponentNativeInherit  : Efl.Eo.NativeClass{
 714    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 715    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 716    {
 717       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 718       if (efl_access_component_z_order_get_static_delegate == null)
 719       efl_access_component_z_order_get_static_delegate = new efl_access_component_z_order_get_delegate(z_order_get);
 720       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_z_order_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_z_order_get_static_delegate)});
 721       if (efl_access_component_extents_get_static_delegate == null)
 722       efl_access_component_extents_get_static_delegate = new efl_access_component_extents_get_delegate(extents_get);
 723       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_extents_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_extents_get_static_delegate)});
 724       if (efl_access_component_extents_set_static_delegate == null)
 725       efl_access_component_extents_set_static_delegate = new efl_access_component_extents_set_delegate(extents_set);
 726       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_extents_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_extents_set_static_delegate)});
 727       if (efl_access_component_screen_position_get_static_delegate == null)
 728       efl_access_component_screen_position_get_static_delegate = new efl_access_component_screen_position_get_delegate(screen_position_get);
 729       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_screen_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_screen_position_get_static_delegate)});
 730       if (efl_access_component_screen_position_set_static_delegate == null)
 731       efl_access_component_screen_position_set_static_delegate = new efl_access_component_screen_position_set_delegate(screen_position_set);
 732       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_screen_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_screen_position_set_static_delegate)});
 733       if (efl_access_component_socket_offset_get_static_delegate == null)
 734       efl_access_component_socket_offset_get_static_delegate = new efl_access_component_socket_offset_get_delegate(socket_offset_get);
 735       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_socket_offset_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_socket_offset_get_static_delegate)});
 736       if (efl_access_component_socket_offset_set_static_delegate == null)
 737       efl_access_component_socket_offset_set_static_delegate = new efl_access_component_socket_offset_set_delegate(socket_offset_set);
 738       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_socket_offset_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_socket_offset_set_static_delegate)});
 739       if (efl_access_component_contains_static_delegate == null)
 740       efl_access_component_contains_static_delegate = new efl_access_component_contains_delegate(contains);
 741       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_contains"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_contains_static_delegate)});
 742       if (efl_access_component_focus_grab_static_delegate == null)
 743       efl_access_component_focus_grab_static_delegate = new efl_access_component_focus_grab_delegate(focus_grab);
 744       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_focus_grab"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_focus_grab_static_delegate)});
 745       if (efl_access_component_accessible_at_point_get_static_delegate == null)
 746       efl_access_component_accessible_at_point_get_static_delegate = new efl_access_component_accessible_at_point_get_delegate(accessible_at_point_get);
 747       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_accessible_at_point_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_accessible_at_point_get_static_delegate)});
 748       if (efl_access_component_highlight_grab_static_delegate == null)
 749       efl_access_component_highlight_grab_static_delegate = new efl_access_component_highlight_grab_delegate(highlight_grab);
 750       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_highlight_grab"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_highlight_grab_static_delegate)});
 751       if (efl_access_component_highlight_clear_static_delegate == null)
 752       efl_access_component_highlight_clear_static_delegate = new efl_access_component_highlight_clear_delegate(highlight_clear);
 753       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_highlight_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_highlight_clear_static_delegate)});
 754       if (efl_gfx_entity_position_get_static_delegate == null)
 755       efl_gfx_entity_position_get_static_delegate = new efl_gfx_entity_position_get_delegate(position_get);
 756       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)});
 757       if (efl_gfx_entity_position_set_static_delegate == null)
 758       efl_gfx_entity_position_set_static_delegate = new efl_gfx_entity_position_set_delegate(position_set);
 759       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)});
 760       if (efl_gfx_entity_size_get_static_delegate == null)
 761       efl_gfx_entity_size_get_static_delegate = new efl_gfx_entity_size_get_delegate(size_get);
 762       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)});
 763       if (efl_gfx_entity_size_set_static_delegate == null)
 764       efl_gfx_entity_size_set_static_delegate = new efl_gfx_entity_size_set_delegate(size_set);
 765       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)});
 766       if (efl_gfx_entity_geometry_get_static_delegate == null)
 767       efl_gfx_entity_geometry_get_static_delegate = new efl_gfx_entity_geometry_get_delegate(geometry_get);
 768       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)});
 769       if (efl_gfx_entity_geometry_set_static_delegate == null)
 770       efl_gfx_entity_geometry_set_static_delegate = new efl_gfx_entity_geometry_set_delegate(geometry_set);
 771       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)});
 772       if (efl_gfx_entity_visible_get_static_delegate == null)
 773       efl_gfx_entity_visible_get_static_delegate = new efl_gfx_entity_visible_get_delegate(visible_get);
 774       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)});
 775       if (efl_gfx_entity_visible_set_static_delegate == null)
 776       efl_gfx_entity_visible_set_static_delegate = new efl_gfx_entity_visible_set_delegate(visible_set);
 777       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)});
 778       if (efl_gfx_entity_scale_get_static_delegate == null)
 779       efl_gfx_entity_scale_get_static_delegate = new efl_gfx_entity_scale_get_delegate(scale_get);
 780       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)});
 781       if (efl_gfx_entity_scale_set_static_delegate == null)
 782       efl_gfx_entity_scale_set_static_delegate = new efl_gfx_entity_scale_set_delegate(scale_set);
 783       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)});
 784       if (efl_gfx_stack_layer_get_static_delegate == null)
 785       efl_gfx_stack_layer_get_static_delegate = new efl_gfx_stack_layer_get_delegate(layer_get);
 786       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)});
 787       if (efl_gfx_stack_layer_set_static_delegate == null)
 788       efl_gfx_stack_layer_set_static_delegate = new efl_gfx_stack_layer_set_delegate(layer_set);
 789       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)});
 790       if (efl_gfx_stack_below_get_static_delegate == null)
 791       efl_gfx_stack_below_get_static_delegate = new efl_gfx_stack_below_get_delegate(below_get);
 792       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)});
 793       if (efl_gfx_stack_above_get_static_delegate == null)
 794       efl_gfx_stack_above_get_static_delegate = new efl_gfx_stack_above_get_delegate(above_get);
 795       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)});
 796       if (efl_gfx_stack_below_static_delegate == null)
 797       efl_gfx_stack_below_static_delegate = new efl_gfx_stack_below_delegate(stack_below);
 798       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)});
 799       if (efl_gfx_stack_raise_to_top_static_delegate == null)
 800       efl_gfx_stack_raise_to_top_static_delegate = new efl_gfx_stack_raise_to_top_delegate(raise_to_top);
 801       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)});
 802       if (efl_gfx_stack_above_static_delegate == null)
 803       efl_gfx_stack_above_static_delegate = new efl_gfx_stack_above_delegate(stack_above);
 804       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)});
 805       if (efl_gfx_stack_lower_to_bottom_static_delegate == null)
 806       efl_gfx_stack_lower_to_bottom_static_delegate = new efl_gfx_stack_lower_to_bottom_delegate(lower_to_bottom);
 807       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)});
 808       return descs;
 809    }
 810    public override IntPtr GetEflClass()
 811    {
 812       return Efl.Access.ComponentConcrete.efl_access_component_mixin_get();
 813    }
 814    public static  IntPtr GetEflClassStatic()
 815    {
 816       return Efl.Access.ComponentConcrete.efl_access_component_mixin_get();
 817    }
 818
 819
 820     private delegate  int efl_access_component_z_order_get_delegate(System.IntPtr obj, System.IntPtr pd);
 821
 822
 823     public delegate  int efl_access_component_z_order_get_api_delegate(System.IntPtr obj);
 824     public static Efl.Eo.FunctionWrapper<efl_access_component_z_order_get_api_delegate> efl_access_component_z_order_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_z_order_get_api_delegate>(_Module, "efl_access_component_z_order_get");
 825     private static  int z_order_get(System.IntPtr obj, System.IntPtr pd)
 826    {
 827       Eina.Log.Debug("function efl_access_component_z_order_get was called");
 828       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 829       if(wrapper != null) {
 830                    int _ret_var = default( int);
 831          try {
 832             _ret_var = ((ComponentConcrete)wrapper).GetZOrder();
 833          } catch (Exception e) {
 834             Eina.Log.Warning($"Callback error: {e.ToString()}");
 835             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 836          }
 837       return _ret_var;
 838       } else {
 839          return efl_access_component_z_order_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 840       }
 841    }
 842    private static efl_access_component_z_order_get_delegate efl_access_component_z_order_get_static_delegate;
 843
 844
 845     private delegate Eina.Rect_StructInternal efl_access_component_extents_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords);
 846
 847
 848     public delegate Eina.Rect_StructInternal efl_access_component_extents_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords);
 849     public static Efl.Eo.FunctionWrapper<efl_access_component_extents_get_api_delegate> efl_access_component_extents_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_extents_get_api_delegate>(_Module, "efl_access_component_extents_get");
 850     private static Eina.Rect_StructInternal extents_get(System.IntPtr obj, System.IntPtr pd,  bool screen_coords)
 851    {
 852       Eina.Log.Debug("function efl_access_component_extents_get was called");
 853       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 854       if(wrapper != null) {
 855                                     Eina.Rect _ret_var = default(Eina.Rect);
 856          try {
 857             _ret_var = ((ComponentConcrete)wrapper).GetExtents( screen_coords);
 858          } catch (Exception e) {
 859             Eina.Log.Warning($"Callback error: {e.ToString()}");
 860             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 861          }
 862                   return Eina.Rect_StructConversion.ToInternal(_ret_var);
 863       } else {
 864          return efl_access_component_extents_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords);
 865       }
 866    }
 867    private static efl_access_component_extents_get_delegate efl_access_component_extents_get_static_delegate;
 868
 869
 870     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_extents_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   Eina.Rect_StructInternal rect);
 871
 872
 873     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_extents_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   Eina.Rect_StructInternal rect);
 874     public static Efl.Eo.FunctionWrapper<efl_access_component_extents_set_api_delegate> efl_access_component_extents_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_extents_set_api_delegate>(_Module, "efl_access_component_extents_set");
 875     private static bool extents_set(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,  Eina.Rect_StructInternal rect)
 876    {
 877       Eina.Log.Debug("function efl_access_component_extents_set was called");
 878       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 879       if(wrapper != null) {
 880                      var _in_rect = Eina.Rect_StructConversion.ToManaged(rect);
 881                                  bool _ret_var = default(bool);
 882          try {
 883             _ret_var = ((ComponentConcrete)wrapper).SetExtents( screen_coords,  _in_rect);
 884          } catch (Exception e) {
 885             Eina.Log.Warning($"Callback error: {e.ToString()}");
 886             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 887          }
 888                               return _ret_var;
 889       } else {
 890          return efl_access_component_extents_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  rect);
 891       }
 892    }
 893    private static efl_access_component_extents_set_delegate efl_access_component_extents_set_static_delegate;
 894
 895
 896     private delegate  void efl_access_component_screen_position_get_delegate(System.IntPtr obj, System.IntPtr pd,   out  int x,   out  int y);
 897
 898
 899     public delegate  void efl_access_component_screen_position_get_api_delegate(System.IntPtr obj,   out  int x,   out  int y);
 900     public static Efl.Eo.FunctionWrapper<efl_access_component_screen_position_get_api_delegate> efl_access_component_screen_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_screen_position_get_api_delegate>(_Module, "efl_access_component_screen_position_get");
 901     private static  void screen_position_get(System.IntPtr obj, System.IntPtr pd,  out  int x,  out  int y)
 902    {
 903       Eina.Log.Debug("function efl_access_component_screen_position_get was called");
 904       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 905       if(wrapper != null) {
 906                            x = default( int);      y = default( int);
 907          try {
 908             ((ComponentConcrete)wrapper).GetScreenPosition( out x,  out y);
 909          } catch (Exception e) {
 910             Eina.Log.Warning($"Callback error: {e.ToString()}");
 911             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 912          }
 913                                     } else {
 914          efl_access_component_screen_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
 915       }
 916    }
 917    private static efl_access_component_screen_position_get_delegate efl_access_component_screen_position_get_static_delegate;
 918
 919
 920     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_screen_position_set_delegate(System.IntPtr obj, System.IntPtr pd,    int x,    int y);
 921
 922
 923     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_screen_position_set_api_delegate(System.IntPtr obj,    int x,    int y);
 924     public static Efl.Eo.FunctionWrapper<efl_access_component_screen_position_set_api_delegate> efl_access_component_screen_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_screen_position_set_api_delegate>(_Module, "efl_access_component_screen_position_set");
 925     private static bool screen_position_set(System.IntPtr obj, System.IntPtr pd,   int x,   int y)
 926    {
 927       Eina.Log.Debug("function efl_access_component_screen_position_set was called");
 928       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 929       if(wrapper != null) {
 930                                                       bool _ret_var = default(bool);
 931          try {
 932             _ret_var = ((ComponentConcrete)wrapper).SetScreenPosition( x,  y);
 933          } catch (Exception e) {
 934             Eina.Log.Warning($"Callback error: {e.ToString()}");
 935             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 936          }
 937                               return _ret_var;
 938       } else {
 939          return efl_access_component_screen_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
 940       }
 941    }
 942    private static efl_access_component_screen_position_set_delegate efl_access_component_screen_position_set_static_delegate;
 943
 944
 945     private delegate  void efl_access_component_socket_offset_get_delegate(System.IntPtr obj, System.IntPtr pd,   out  int x,   out  int y);
 946
 947
 948     public delegate  void efl_access_component_socket_offset_get_api_delegate(System.IntPtr obj,   out  int x,   out  int y);
 949     public static Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_get_api_delegate> efl_access_component_socket_offset_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_get_api_delegate>(_Module, "efl_access_component_socket_offset_get");
 950     private static  void socket_offset_get(System.IntPtr obj, System.IntPtr pd,  out  int x,  out  int y)
 951    {
 952       Eina.Log.Debug("function efl_access_component_socket_offset_get was called");
 953       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 954       if(wrapper != null) {
 955                            x = default( int);      y = default( int);
 956          try {
 957             ((ComponentConcrete)wrapper).GetSocketOffset( out x,  out y);
 958          } catch (Exception e) {
 959             Eina.Log.Warning($"Callback error: {e.ToString()}");
 960             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 961          }
 962                                     } else {
 963          efl_access_component_socket_offset_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
 964       }
 965    }
 966    private static efl_access_component_socket_offset_get_delegate efl_access_component_socket_offset_get_static_delegate;
 967
 968
 969     private delegate  void efl_access_component_socket_offset_set_delegate(System.IntPtr obj, System.IntPtr pd,    int x,    int y);
 970
 971
 972     public delegate  void efl_access_component_socket_offset_set_api_delegate(System.IntPtr obj,    int x,    int y);
 973     public static Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_set_api_delegate> efl_access_component_socket_offset_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_set_api_delegate>(_Module, "efl_access_component_socket_offset_set");
 974     private static  void socket_offset_set(System.IntPtr obj, System.IntPtr pd,   int x,   int y)
 975    {
 976       Eina.Log.Debug("function efl_access_component_socket_offset_set was called");
 977       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 978       if(wrapper != null) {
 979
 980          try {
 981             ((ComponentConcrete)wrapper).SetSocketOffset( x,  y);
 982          } catch (Exception e) {
 983             Eina.Log.Warning($"Callback error: {e.ToString()}");
 984             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 985          }
 986                                     } else {
 987          efl_access_component_socket_offset_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
 988       }
 989    }
 990    private static efl_access_component_socket_offset_set_delegate efl_access_component_socket_offset_set_static_delegate;
 991
 992
 993     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_contains_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,    int x,    int y);
 994
 995
 996     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_contains_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,    int x,    int y);
 997     public static Efl.Eo.FunctionWrapper<efl_access_component_contains_api_delegate> efl_access_component_contains_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_contains_api_delegate>(_Module, "efl_access_component_contains");
 998     private static bool contains(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,   int x,   int y)
 999    {
1000       Eina.Log.Debug("function efl_access_component_contains was called");
1001       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1002       if(wrapper != null) {
1003                                                                         bool _ret_var = default(bool);
1004          try {
1005             _ret_var = ((ComponentConcrete)wrapper).Contains( screen_coords,  x,  y);
1006          } catch (Exception e) {
1007             Eina.Log.Warning($"Callback error: {e.ToString()}");
1008             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1009          }
1010                                           return _ret_var;
1011       } else {
1012          return efl_access_component_contains_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  x,  y);
1013       }
1014    }
1015    private static efl_access_component_contains_delegate efl_access_component_contains_static_delegate;
1016
1017
1018     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_focus_grab_delegate(System.IntPtr obj, System.IntPtr pd);
1019
1020
1021     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_focus_grab_api_delegate(System.IntPtr obj);
1022     public static Efl.Eo.FunctionWrapper<efl_access_component_focus_grab_api_delegate> efl_access_component_focus_grab_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_focus_grab_api_delegate>(_Module, "efl_access_component_focus_grab");
1023     private static bool focus_grab(System.IntPtr obj, System.IntPtr pd)
1024    {
1025       Eina.Log.Debug("function efl_access_component_focus_grab was called");
1026       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1027       if(wrapper != null) {
1028                   bool _ret_var = default(bool);
1029          try {
1030             _ret_var = ((ComponentConcrete)wrapper).GrabFocus();
1031          } catch (Exception e) {
1032             Eina.Log.Warning($"Callback error: {e.ToString()}");
1033             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1034          }
1035       return _ret_var;
1036       } else {
1037          return efl_access_component_focus_grab_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1038       }
1039    }
1040    private static efl_access_component_focus_grab_delegate efl_access_component_focus_grab_static_delegate;
1041
1042
1043    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_access_component_accessible_at_point_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,    int x,    int y);
1044
1045
1046    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_access_component_accessible_at_point_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,    int x,    int y);
1047     public static Efl.Eo.FunctionWrapper<efl_access_component_accessible_at_point_get_api_delegate> efl_access_component_accessible_at_point_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_accessible_at_point_get_api_delegate>(_Module, "efl_access_component_accessible_at_point_get");
1048     private static Efl.Object accessible_at_point_get(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,   int x,   int y)
1049    {
1050       Eina.Log.Debug("function efl_access_component_accessible_at_point_get was called");
1051       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1052       if(wrapper != null) {
1053                                                                         Efl.Object _ret_var = default(Efl.Object);
1054          try {
1055             _ret_var = ((ComponentConcrete)wrapper).GetAccessibleAtPoint( screen_coords,  x,  y);
1056          } catch (Exception e) {
1057             Eina.Log.Warning($"Callback error: {e.ToString()}");
1058             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1059          }
1060                                           return _ret_var;
1061       } else {
1062          return efl_access_component_accessible_at_point_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  x,  y);
1063       }
1064    }
1065    private static efl_access_component_accessible_at_point_get_delegate efl_access_component_accessible_at_point_get_static_delegate;
1066
1067
1068     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_highlight_grab_delegate(System.IntPtr obj, System.IntPtr pd);
1069
1070
1071     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_highlight_grab_api_delegate(System.IntPtr obj);
1072     public static Efl.Eo.FunctionWrapper<efl_access_component_highlight_grab_api_delegate> efl_access_component_highlight_grab_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_highlight_grab_api_delegate>(_Module, "efl_access_component_highlight_grab");
1073     private static bool highlight_grab(System.IntPtr obj, System.IntPtr pd)
1074    {
1075       Eina.Log.Debug("function efl_access_component_highlight_grab was called");
1076       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1077       if(wrapper != null) {
1078                   bool _ret_var = default(bool);
1079          try {
1080             _ret_var = ((ComponentConcrete)wrapper).GrabHighlight();
1081          } catch (Exception e) {
1082             Eina.Log.Warning($"Callback error: {e.ToString()}");
1083             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1084          }
1085       return _ret_var;
1086       } else {
1087          return efl_access_component_highlight_grab_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1088       }
1089    }
1090    private static efl_access_component_highlight_grab_delegate efl_access_component_highlight_grab_static_delegate;
1091
1092
1093     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_highlight_clear_delegate(System.IntPtr obj, System.IntPtr pd);
1094
1095
1096     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_highlight_clear_api_delegate(System.IntPtr obj);
1097     public static Efl.Eo.FunctionWrapper<efl_access_component_highlight_clear_api_delegate> efl_access_component_highlight_clear_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_highlight_clear_api_delegate>(_Module, "efl_access_component_highlight_clear");
1098     private static bool highlight_clear(System.IntPtr obj, System.IntPtr pd)
1099    {
1100       Eina.Log.Debug("function efl_access_component_highlight_clear was called");
1101       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1102       if(wrapper != null) {
1103                   bool _ret_var = default(bool);
1104          try {
1105             _ret_var = ((ComponentConcrete)wrapper).ClearHighlight();
1106          } catch (Exception e) {
1107             Eina.Log.Warning($"Callback error: {e.ToString()}");
1108             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1109          }
1110       return _ret_var;
1111       } else {
1112          return efl_access_component_highlight_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1113       }
1114    }
1115    private static efl_access_component_highlight_clear_delegate efl_access_component_highlight_clear_static_delegate;
1116
1117
1118     private delegate Eina.Position2D_StructInternal efl_gfx_entity_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1119
1120
1121     public delegate Eina.Position2D_StructInternal efl_gfx_entity_position_get_api_delegate(System.IntPtr obj);
1122     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");
1123     private static Eina.Position2D_StructInternal position_get(System.IntPtr obj, System.IntPtr pd)
1124    {
1125       Eina.Log.Debug("function efl_gfx_entity_position_get was called");
1126       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1127       if(wrapper != null) {
1128                   Eina.Position2D _ret_var = default(Eina.Position2D);
1129          try {
1130             _ret_var = ((ComponentConcrete)wrapper).GetPosition();
1131          } catch (Exception e) {
1132             Eina.Log.Warning($"Callback error: {e.ToString()}");
1133             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1134          }
1135       return Eina.Position2D_StructConversion.ToInternal(_ret_var);
1136       } else {
1137          return efl_gfx_entity_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1138       }
1139    }
1140    private static efl_gfx_entity_position_get_delegate efl_gfx_entity_position_get_static_delegate;
1141
1142
1143     private delegate  void efl_gfx_entity_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D_StructInternal pos);
1144
1145
1146     public delegate  void efl_gfx_entity_position_set_api_delegate(System.IntPtr obj,   Eina.Position2D_StructInternal pos);
1147     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");
1148     private static  void position_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D_StructInternal pos)
1149    {
1150       Eina.Log.Debug("function efl_gfx_entity_position_set was called");
1151       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1152       if(wrapper != null) {
1153                var _in_pos = Eina.Position2D_StructConversion.ToManaged(pos);
1154
1155          try {
1156             ((ComponentConcrete)wrapper).SetPosition( _in_pos);
1157          } catch (Exception e) {
1158             Eina.Log.Warning($"Callback error: {e.ToString()}");
1159             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1160          }
1161                         } else {
1162          efl_gfx_entity_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pos);
1163       }
1164    }
1165    private static efl_gfx_entity_position_set_delegate efl_gfx_entity_position_set_static_delegate;
1166
1167
1168     private delegate Eina.Size2D_StructInternal efl_gfx_entity_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1169
1170
1171     public delegate Eina.Size2D_StructInternal efl_gfx_entity_size_get_api_delegate(System.IntPtr obj);
1172     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");
1173     private static Eina.Size2D_StructInternal size_get(System.IntPtr obj, System.IntPtr pd)
1174    {
1175       Eina.Log.Debug("function efl_gfx_entity_size_get was called");
1176       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1177       if(wrapper != null) {
1178                   Eina.Size2D _ret_var = default(Eina.Size2D);
1179          try {
1180             _ret_var = ((ComponentConcrete)wrapper).GetSize();
1181          } catch (Exception e) {
1182             Eina.Log.Warning($"Callback error: {e.ToString()}");
1183             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1184          }
1185       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
1186       } else {
1187          return efl_gfx_entity_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1188       }
1189    }
1190    private static efl_gfx_entity_size_get_delegate efl_gfx_entity_size_get_static_delegate;
1191
1192
1193     private delegate  void efl_gfx_entity_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal size);
1194
1195
1196     public delegate  void efl_gfx_entity_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal size);
1197     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");
1198     private static  void size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal size)
1199    {
1200       Eina.Log.Debug("function efl_gfx_entity_size_set was called");
1201       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1202       if(wrapper != null) {
1203                var _in_size = Eina.Size2D_StructConversion.ToManaged(size);
1204
1205          try {
1206             ((ComponentConcrete)wrapper).SetSize( _in_size);
1207          } catch (Exception e) {
1208             Eina.Log.Warning($"Callback error: {e.ToString()}");
1209             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1210          }
1211                         } else {
1212          efl_gfx_entity_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
1213       }
1214    }
1215    private static efl_gfx_entity_size_set_delegate efl_gfx_entity_size_set_static_delegate;
1216
1217
1218     private delegate Eina.Rect_StructInternal efl_gfx_entity_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
1219
1220
1221     public delegate Eina.Rect_StructInternal efl_gfx_entity_geometry_get_api_delegate(System.IntPtr obj);
1222     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");
1223     private static Eina.Rect_StructInternal geometry_get(System.IntPtr obj, System.IntPtr pd)
1224    {
1225       Eina.Log.Debug("function efl_gfx_entity_geometry_get was called");
1226       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1227       if(wrapper != null) {
1228                   Eina.Rect _ret_var = default(Eina.Rect);
1229          try {
1230             _ret_var = ((ComponentConcrete)wrapper).GetGeometry();
1231          } catch (Exception e) {
1232             Eina.Log.Warning($"Callback error: {e.ToString()}");
1233             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1234          }
1235       return Eina.Rect_StructConversion.ToInternal(_ret_var);
1236       } else {
1237          return efl_gfx_entity_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1238       }
1239    }
1240    private static efl_gfx_entity_geometry_get_delegate efl_gfx_entity_geometry_get_static_delegate;
1241
1242
1243     private delegate  void efl_gfx_entity_geometry_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect_StructInternal rect);
1244
1245
1246     public delegate  void efl_gfx_entity_geometry_set_api_delegate(System.IntPtr obj,   Eina.Rect_StructInternal rect);
1247     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");
1248     private static  void geometry_set(System.IntPtr obj, System.IntPtr pd,  Eina.Rect_StructInternal rect)
1249    {
1250       Eina.Log.Debug("function efl_gfx_entity_geometry_set was called");
1251       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1252       if(wrapper != null) {
1253                var _in_rect = Eina.Rect_StructConversion.ToManaged(rect);
1254
1255          try {
1256             ((ComponentConcrete)wrapper).SetGeometry( _in_rect);
1257          } catch (Exception e) {
1258             Eina.Log.Warning($"Callback error: {e.ToString()}");
1259             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1260          }
1261                         } else {
1262          efl_gfx_entity_geometry_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  rect);
1263       }
1264    }
1265    private static efl_gfx_entity_geometry_set_delegate efl_gfx_entity_geometry_set_static_delegate;
1266
1267
1268     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_entity_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
1269
1270
1271     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_entity_visible_get_api_delegate(System.IntPtr obj);
1272     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");
1273     private static bool visible_get(System.IntPtr obj, System.IntPtr pd)
1274    {
1275       Eina.Log.Debug("function efl_gfx_entity_visible_get was called");
1276       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1277       if(wrapper != null) {
1278                   bool _ret_var = default(bool);
1279          try {
1280             _ret_var = ((ComponentConcrete)wrapper).GetVisible();
1281          } catch (Exception e) {
1282             Eina.Log.Warning($"Callback error: {e.ToString()}");
1283             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1284          }
1285       return _ret_var;
1286       } else {
1287          return efl_gfx_entity_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1288       }
1289    }
1290    private static efl_gfx_entity_visible_get_delegate efl_gfx_entity_visible_get_static_delegate;
1291
1292
1293     private delegate  void efl_gfx_entity_visible_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool v);
1294
1295
1296     public delegate  void efl_gfx_entity_visible_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool v);
1297     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");
1298     private static  void visible_set(System.IntPtr obj, System.IntPtr pd,  bool v)
1299    {
1300       Eina.Log.Debug("function efl_gfx_entity_visible_set was called");
1301       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1302       if(wrapper != null) {
1303
1304          try {
1305             ((ComponentConcrete)wrapper).SetVisible( v);
1306          } catch (Exception e) {
1307             Eina.Log.Warning($"Callback error: {e.ToString()}");
1308             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1309          }
1310                         } else {
1311          efl_gfx_entity_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  v);
1312       }
1313    }
1314    private static efl_gfx_entity_visible_set_delegate efl_gfx_entity_visible_set_static_delegate;
1315
1316
1317     private delegate double efl_gfx_entity_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1318
1319
1320     public delegate double efl_gfx_entity_scale_get_api_delegate(System.IntPtr obj);
1321     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");
1322     private static double scale_get(System.IntPtr obj, System.IntPtr pd)
1323    {
1324       Eina.Log.Debug("function efl_gfx_entity_scale_get was called");
1325       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1326       if(wrapper != null) {
1327                   double _ret_var = default(double);
1328          try {
1329             _ret_var = ((ComponentConcrete)wrapper).GetScale();
1330          } catch (Exception e) {
1331             Eina.Log.Warning($"Callback error: {e.ToString()}");
1332             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1333          }
1334       return _ret_var;
1335       } else {
1336          return efl_gfx_entity_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1337       }
1338    }
1339    private static efl_gfx_entity_scale_get_delegate efl_gfx_entity_scale_get_static_delegate;
1340
1341
1342     private delegate  void efl_gfx_entity_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,   double scale);
1343
1344
1345     public delegate  void efl_gfx_entity_scale_set_api_delegate(System.IntPtr obj,   double scale);
1346     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");
1347     private static  void scale_set(System.IntPtr obj, System.IntPtr pd,  double scale)
1348    {
1349       Eina.Log.Debug("function efl_gfx_entity_scale_set was called");
1350       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1351       if(wrapper != null) {
1352
1353          try {
1354             ((ComponentConcrete)wrapper).SetScale( scale);
1355          } catch (Exception e) {
1356             Eina.Log.Warning($"Callback error: {e.ToString()}");
1357             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1358          }
1359                         } else {
1360          efl_gfx_entity_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scale);
1361       }
1362    }
1363    private static efl_gfx_entity_scale_set_delegate efl_gfx_entity_scale_set_static_delegate;
1364
1365
1366     private delegate  short efl_gfx_stack_layer_get_delegate(System.IntPtr obj, System.IntPtr pd);
1367
1368
1369     public delegate  short efl_gfx_stack_layer_get_api_delegate(System.IntPtr obj);
1370     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");
1371     private static  short layer_get(System.IntPtr obj, System.IntPtr pd)
1372    {
1373       Eina.Log.Debug("function efl_gfx_stack_layer_get was called");
1374       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1375       if(wrapper != null) {
1376                    short _ret_var = default( short);
1377          try {
1378             _ret_var = ((ComponentConcrete)wrapper).GetLayer();
1379          } catch (Exception e) {
1380             Eina.Log.Warning($"Callback error: {e.ToString()}");
1381             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1382          }
1383       return _ret_var;
1384       } else {
1385          return efl_gfx_stack_layer_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1386       }
1387    }
1388    private static efl_gfx_stack_layer_get_delegate efl_gfx_stack_layer_get_static_delegate;
1389
1390
1391     private delegate  void efl_gfx_stack_layer_set_delegate(System.IntPtr obj, System.IntPtr pd,    short l);
1392
1393
1394     public delegate  void efl_gfx_stack_layer_set_api_delegate(System.IntPtr obj,    short l);
1395     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");
1396     private static  void layer_set(System.IntPtr obj, System.IntPtr pd,   short l)
1397    {
1398       Eina.Log.Debug("function efl_gfx_stack_layer_set was called");
1399       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1400       if(wrapper != null) {
1401
1402          try {
1403             ((ComponentConcrete)wrapper).SetLayer( l);
1404          } catch (Exception e) {
1405             Eina.Log.Warning($"Callback error: {e.ToString()}");
1406             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1407          }
1408                         } else {
1409          efl_gfx_stack_layer_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  l);
1410       }
1411    }
1412    private static efl_gfx_stack_layer_set_delegate efl_gfx_stack_layer_set_static_delegate;
1413
1414
1415    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Stack efl_gfx_stack_below_get_delegate(System.IntPtr obj, System.IntPtr pd);
1416
1417
1418    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Stack efl_gfx_stack_below_get_api_delegate(System.IntPtr obj);
1419     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");
1420     private static Efl.Gfx.Stack below_get(System.IntPtr obj, System.IntPtr pd)
1421    {
1422       Eina.Log.Debug("function efl_gfx_stack_below_get was called");
1423       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1424       if(wrapper != null) {
1425                   Efl.Gfx.Stack _ret_var = default(Efl.Gfx.Stack);
1426          try {
1427             _ret_var = ((ComponentConcrete)wrapper).GetBelow();
1428          } catch (Exception e) {
1429             Eina.Log.Warning($"Callback error: {e.ToString()}");
1430             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1431          }
1432       return _ret_var;
1433       } else {
1434          return efl_gfx_stack_below_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1435       }
1436    }
1437    private static efl_gfx_stack_below_get_delegate efl_gfx_stack_below_get_static_delegate;
1438
1439
1440    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Stack efl_gfx_stack_above_get_delegate(System.IntPtr obj, System.IntPtr pd);
1441
1442
1443    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Stack efl_gfx_stack_above_get_api_delegate(System.IntPtr obj);
1444     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");
1445     private static Efl.Gfx.Stack above_get(System.IntPtr obj, System.IntPtr pd)
1446    {
1447       Eina.Log.Debug("function efl_gfx_stack_above_get was called");
1448       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1449       if(wrapper != null) {
1450                   Efl.Gfx.Stack _ret_var = default(Efl.Gfx.Stack);
1451          try {
1452             _ret_var = ((ComponentConcrete)wrapper).GetAbove();
1453          } catch (Exception e) {
1454             Eina.Log.Warning($"Callback error: {e.ToString()}");
1455             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1456          }
1457       return _ret_var;
1458       } else {
1459          return efl_gfx_stack_above_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1460       }
1461    }
1462    private static efl_gfx_stack_above_get_delegate efl_gfx_stack_above_get_static_delegate;
1463
1464
1465     private delegate  void efl_gfx_stack_below_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Stack below);
1466
1467
1468     public delegate  void efl_gfx_stack_below_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Stack below);
1469     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");
1470     private static  void stack_below(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Stack below)
1471    {
1472       Eina.Log.Debug("function efl_gfx_stack_below was called");
1473       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1474       if(wrapper != null) {
1475
1476          try {
1477             ((ComponentConcrete)wrapper).StackBelow( below);
1478          } catch (Exception e) {
1479             Eina.Log.Warning($"Callback error: {e.ToString()}");
1480             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1481          }
1482                         } else {
1483          efl_gfx_stack_below_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  below);
1484       }
1485    }
1486    private static efl_gfx_stack_below_delegate efl_gfx_stack_below_static_delegate;
1487
1488
1489     private delegate  void efl_gfx_stack_raise_to_top_delegate(System.IntPtr obj, System.IntPtr pd);
1490
1491
1492     public delegate  void efl_gfx_stack_raise_to_top_api_delegate(System.IntPtr obj);
1493     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");
1494     private static  void raise_to_top(System.IntPtr obj, System.IntPtr pd)
1495    {
1496       Eina.Log.Debug("function efl_gfx_stack_raise_to_top was called");
1497       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1498       if(wrapper != null) {
1499
1500          try {
1501             ((ComponentConcrete)wrapper).RaiseToTop();
1502          } catch (Exception e) {
1503             Eina.Log.Warning($"Callback error: {e.ToString()}");
1504             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1505          }
1506             } else {
1507          efl_gfx_stack_raise_to_top_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1508       }
1509    }
1510    private static efl_gfx_stack_raise_to_top_delegate efl_gfx_stack_raise_to_top_static_delegate;
1511
1512
1513     private delegate  void efl_gfx_stack_above_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Stack above);
1514
1515
1516     public delegate  void efl_gfx_stack_above_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.StackConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Stack above);
1517     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");
1518     private static  void stack_above(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Stack above)
1519    {
1520       Eina.Log.Debug("function efl_gfx_stack_above was called");
1521       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1522       if(wrapper != null) {
1523
1524          try {
1525             ((ComponentConcrete)wrapper).StackAbove( above);
1526          } catch (Exception e) {
1527             Eina.Log.Warning($"Callback error: {e.ToString()}");
1528             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1529          }
1530                         } else {
1531          efl_gfx_stack_above_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  above);
1532       }
1533    }
1534    private static efl_gfx_stack_above_delegate efl_gfx_stack_above_static_delegate;
1535
1536
1537     private delegate  void efl_gfx_stack_lower_to_bottom_delegate(System.IntPtr obj, System.IntPtr pd);
1538
1539
1540     public delegate  void efl_gfx_stack_lower_to_bottom_api_delegate(System.IntPtr obj);
1541     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");
1542     private static  void lower_to_bottom(System.IntPtr obj, System.IntPtr pd)
1543    {
1544       Eina.Log.Debug("function efl_gfx_stack_lower_to_bottom was called");
1545       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1546       if(wrapper != null) {
1547
1548          try {
1549             ((ComponentConcrete)wrapper).LowerToBottom();
1550          } catch (Exception e) {
1551             Eina.Log.Warning($"Callback error: {e.ToString()}");
1552             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1553          }
1554             } else {
1555          efl_gfx_stack_lower_to_bottom_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1556       }
1557    }
1558    private static efl_gfx_stack_lower_to_bottom_delegate efl_gfx_stack_lower_to_bottom_static_delegate;
1559 }
1560 } }