internals/src/EflSharp/EflSharp/efl/efl_canvas_scene.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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Interface containing basic canvas-related methods and events.
  13 /// (Since EFL 1.22)</summary>
  14 [Efl.Canvas.ISceneConcrete.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public interface IScene :
  17     Efl.Eo.IWrapper, IDisposable
  18 {
  19     /// <summary>Get the maximum image size the canvas can possibly handle.
  20 /// This function returns the largest image or surface size that the canvas can handle in pixels, and if there is one, returns <c>true</c>. It returns <c>false</c> if no extra constraint on maximum image size exists.
  21 ///
  22 /// The default limit is 65535x65535.
  23 /// (Since EFL 1.22)</summary>
  24 /// <param name="max">The maximum image size (in pixels).</param>
  25 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  26 bool GetImageMaxSize(out Eina.Size2D max);
  27     /// <summary>Get if the canvas is currently calculating group objects.
  28 /// (Since EFL 1.22)</summary>
  29 /// <returns><c>true</c> if currently calculating group objects.</returns>
  30 bool GetGroupObjectsCalculating();
  31     /// <summary>Get a device by name.
  32 /// (Since EFL 1.22)</summary>
  33 /// <param name="name">The name of the seat to find.</param>
  34 /// <returns>The device or seat, <c>null</c> if not found.</returns>
  35 Efl.Input.Device GetDevice(System.String name);
  36     /// <summary>Get a seat by id.
  37 /// (Since EFL 1.22)</summary>
  38 /// <param name="id">The id of the seat to find.</param>
  39 /// <returns>The seat or <c>null</c> if not found.</returns>
  40 Efl.Input.Device GetSeat(int id);
  41     /// <summary>Get the default seat.
  42 /// (Since EFL 1.22)</summary>
  43 /// <returns>The default seat or <c>null</c> if one does not exist.</returns>
  44 Efl.Input.Device GetSeatDefault();
  45     /// <summary>This function returns the current known pointer coordinates
  46 /// This function returns the current position of the main input pointer (mouse, pen, etc...).
  47 /// (Since EFL 1.22)</summary>
  48 /// <param name="seat">The seat, or <c>null</c> to use the default.</param>
  49 /// <param name="pos">The pointer position in pixels.</param>
  50 /// <returns><c>true</c> if a pointer exists for the given seat, otherwise <c>false</c>.</returns>
  51 bool GetPointerPosition(Efl.Input.Device seat, out Eina.Position2D pos);
  52     /// <summary>Call user-provided <c>calculate</c> group functions and unset the flag signalling that the object needs to get recalculated to all group objects in the canvas.
  53 /// (Since EFL 1.22)</summary>
  54 void CalculateGroupObjects();
  55     /// <summary>Retrieve a list of objects at a given position in a canvas.
  56 /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas covering the given position. The user can exclude from the query objects which are hidden and/or which are set to pass events.
  57 ///
  58 /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
  59 /// (Since EFL 1.22)</summary>
  60 /// <param name="pos">The pixel position.</param>
  61 /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
  62 /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
  63 /// <returns>The list of objects that are over the given position in <c>e</c>.</returns>
  64 Eina.Iterator<Efl.Gfx.IEntity> GetObjectsAtXy(Eina.Position2D pos, bool include_pass_events_objects, bool include_hidden_objects);
  65     /// <summary>Retrieve the object stacked at the top of a given position in a canvas.
  66 /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas covering the given position. The user can exclude from the query objects which are hidden and/or which are set to pass events.
  67 ///
  68 /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
  69 /// (Since EFL 1.22)</summary>
  70 /// <param name="pos">The pixel position.</param>
  71 /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
  72 /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
  73 /// <returns>The canvas object that is over all other objects at the given position.</returns>
  74 Efl.Gfx.IEntity GetObjectTopAtXy(Eina.Position2D pos, bool include_pass_events_objects, bool include_hidden_objects);
  75     /// <summary>Retrieve a list of objects overlapping a given rectangular region in a canvas.
  76 /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas overlapping with the given rectangular region. The user can exclude from the query objects which are hidden and/or which are set to pass events.
  77 ///
  78 /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
  79 /// (Since EFL 1.22)</summary>
  80 /// <param name="rect">The rectangular region.</param>
  81 /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
  82 /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
  83 /// <returns>Iterator to objects</returns>
  84 Eina.Iterator<Efl.Gfx.IEntity> GetObjectsInRectangle(Eina.Rect rect, bool include_pass_events_objects, bool include_hidden_objects);
  85     /// <summary>Retrieve the canvas object stacked at the top of a given rectangular region in a canvas
  86 /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas overlapping with the given rectangular region. The user can exclude from the query objects which are hidden and/or which are set to pass events.
  87 ///
  88 /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
  89 /// (Since EFL 1.22)</summary>
  90 /// <param name="rect">The rectangular region.</param>
  91 /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
  92 /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
  93 /// <returns>The object that is over all other objects at the given rectangular region.</returns>
  94 Efl.Gfx.IEntity GetObjectTopInRectangle(Eina.Rect rect, bool include_pass_events_objects, bool include_hidden_objects);
  95     /// <summary>Iterate over the available input device seats for the canvas.
  96 /// A &quot;seat&quot; is the term used for a group of input devices, typically including a pointer and a keyboard. A seat object is the parent of the individual input devices.
  97 /// (Since EFL 1.22)</summary>
  98 /// <returns>An iterator over the attached seats.</returns>
  99 Eina.Iterator<Efl.Input.Device> Seats();
 100                                                     /// <summary>Called when scene got focus
 101     /// (Since EFL 1.22)</summary>
 102     event EventHandler SceneFocusInEvt;
 103     /// <summary>Called when scene lost focus
 104     /// (Since EFL 1.22)</summary>
 105     event EventHandler SceneFocusOutEvt;
 106     /// <summary>Called when object got focus
 107     /// (Since EFL 1.22)</summary>
 108     event EventHandler<Efl.Canvas.ISceneObjectFocusInEvt_Args> ObjectFocusInEvt;
 109     /// <summary>Called when object lost focus
 110     /// (Since EFL 1.22)</summary>
 111     event EventHandler<Efl.Canvas.ISceneObjectFocusOutEvt_Args> ObjectFocusOutEvt;
 112     /// <summary>Called when pre render happens
 113     /// (Since EFL 1.22)</summary>
 114     event EventHandler RenderPreEvt;
 115     /// <summary>Called when post render happens
 116     /// (Since EFL 1.22)</summary>
 117     event EventHandler<Efl.Canvas.ISceneRenderPostEvt_Args> RenderPostEvt;
 118     /// <summary>Called when input device changed
 119     /// (Since EFL 1.22)</summary>
 120     event EventHandler<Efl.Canvas.ISceneDeviceChangedEvt_Args> DeviceChangedEvt;
 121     /// <summary>Called when input device was added
 122     /// (Since EFL 1.22)</summary>
 123     event EventHandler<Efl.Canvas.ISceneDeviceAddedEvt_Args> DeviceAddedEvt;
 124     /// <summary>Called when input device was removed
 125     /// (Since EFL 1.22)</summary>
 126     event EventHandler<Efl.Canvas.ISceneDeviceRemovedEvt_Args> DeviceRemovedEvt;
 127     /// <summary>Get if the canvas is currently calculating group objects.
 128     /// (Since EFL 1.22)</summary>
 129     /// <value><c>true</c> if currently calculating group objects.</value>
 130     bool GroupObjectsCalculating {
 131         get ;
 132     }
 133     /// <summary>Get the default seat attached to this canvas.
 134     /// A canvas may have exactly one default seat.
 135     ///
 136     /// See also <see cref="Efl.Canvas.IScene.GetDevice"/> to find a seat by name. See also <see cref="Efl.Canvas.IScene.GetSeat"/> to find a seat by id.
 137     /// (Since EFL 1.22)</summary>
 138     /// <value>The default seat or <c>null</c> if one does not exist.</value>
 139     Efl.Input.Device SeatDefault {
 140         get ;
 141     }
 142 }
 143 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.ObjectFocusInEvt"/>.</summary>
 144 [Efl.Eo.BindingEntity]
 145 public class ISceneObjectFocusInEvt_Args : EventArgs {
 146     ///<summary>Actual event payload.</summary>
 147     public Efl.Input.Focus arg { get; set; }
 148 }
 149 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.ObjectFocusOutEvt"/>.</summary>
 150 [Efl.Eo.BindingEntity]
 151 public class ISceneObjectFocusOutEvt_Args : EventArgs {
 152     ///<summary>Actual event payload.</summary>
 153     public Efl.Input.Focus arg { get; set; }
 154 }
 155 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.RenderPostEvt"/>.</summary>
 156 [Efl.Eo.BindingEntity]
 157 public class ISceneRenderPostEvt_Args : EventArgs {
 158     ///<summary>Actual event payload.</summary>
 159     public Efl.Gfx.Event.RenderPost arg { get; set; }
 160 }
 161 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.DeviceChangedEvt"/>.</summary>
 162 [Efl.Eo.BindingEntity]
 163 public class ISceneDeviceChangedEvt_Args : EventArgs {
 164     ///<summary>Actual event payload.</summary>
 165     public Efl.Input.Device arg { get; set; }
 166 }
 167 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.DeviceAddedEvt"/>.</summary>
 168 [Efl.Eo.BindingEntity]
 169 public class ISceneDeviceAddedEvt_Args : EventArgs {
 170     ///<summary>Actual event payload.</summary>
 171     public Efl.Input.Device arg { get; set; }
 172 }
 173 ///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.DeviceRemovedEvt"/>.</summary>
 174 [Efl.Eo.BindingEntity]
 175 public class ISceneDeviceRemovedEvt_Args : EventArgs {
 176     ///<summary>Actual event payload.</summary>
 177     public Efl.Input.Device arg { get; set; }
 178 }
 179 /// <summary>Interface containing basic canvas-related methods and events.
 180 /// (Since EFL 1.22)</summary>
 181 sealed public class ISceneConcrete :
 182     Efl.Eo.EoWrapper
 183     , IScene
 184
 185 {
 186     ///<summary>Pointer to the native class description.</summary>
 187     public override System.IntPtr NativeClass
 188     {
 189         get
 190         {
 191             if (((object)this).GetType() == typeof(ISceneConcrete))
 192             {
 193                 return GetEflClassStatic();
 194             }
 195             else
 196             {
 197                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 198             }
 199         }
 200     }
 201
 202     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 203     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 204     private ISceneConcrete(ConstructingHandle ch) : base(ch)
 205     {
 206     }
 207
 208     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 209         efl_canvas_scene_interface_get();
 210     /// <summary>Initializes a new instance of the <see cref="IScene"/> class.
 211     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 212     /// <param name="wh">The native pointer to be wrapped.</param>
 213     private ISceneConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 214     {
 215     }
 216
 217     /// <summary>Called when scene got focus
 218     /// (Since EFL 1.22)</summary>
 219     public event EventHandler SceneFocusInEvt
 220     {
 221         add
 222         {
 223             lock (eflBindingEventLock)
 224             {
 225                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 226                 {
 227                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 228                     if (obj != null)
 229                     {
 230                         EventArgs args = EventArgs.Empty;
 231                         try
 232                         {
 233                             value?.Invoke(obj, args);
 234                         }
 235                         catch (Exception e)
 236                         {
 237                             Eina.Log.Error(e.ToString());
 238                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 239                         }
 240                     }
 241                 };
 242
 243                 string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
 244                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 245             }
 246         }
 247
 248         remove
 249         {
 250             lock (eflBindingEventLock)
 251             {
 252                 string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
 253                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 254             }
 255         }
 256     }
 257     ///<summary>Method to raise event SceneFocusInEvt.</summary>
 258     public void OnSceneFocusInEvt(EventArgs e)
 259     {
 260         var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
 261         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 262         if (desc == IntPtr.Zero)
 263         {
 264             Eina.Log.Error($"Failed to get native event {key}");
 265             return;
 266         }
 267
 268         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 269     }
 270     /// <summary>Called when scene lost focus
 271     /// (Since EFL 1.22)</summary>
 272     public event EventHandler SceneFocusOutEvt
 273     {
 274         add
 275         {
 276             lock (eflBindingEventLock)
 277             {
 278                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 279                 {
 280                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 281                     if (obj != null)
 282                     {
 283                         EventArgs args = EventArgs.Empty;
 284                         try
 285                         {
 286                             value?.Invoke(obj, args);
 287                         }
 288                         catch (Exception e)
 289                         {
 290                             Eina.Log.Error(e.ToString());
 291                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 292                         }
 293                     }
 294                 };
 295
 296                 string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
 297                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 298             }
 299         }
 300
 301         remove
 302         {
 303             lock (eflBindingEventLock)
 304             {
 305                 string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
 306                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 307             }
 308         }
 309     }
 310     ///<summary>Method to raise event SceneFocusOutEvt.</summary>
 311     public void OnSceneFocusOutEvt(EventArgs e)
 312     {
 313         var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
 314         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 315         if (desc == IntPtr.Zero)
 316         {
 317             Eina.Log.Error($"Failed to get native event {key}");
 318             return;
 319         }
 320
 321         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 322     }
 323     /// <summary>Called when object got focus
 324     /// (Since EFL 1.22)</summary>
 325     public event EventHandler<Efl.Canvas.ISceneObjectFocusInEvt_Args> ObjectFocusInEvt
 326     {
 327         add
 328         {
 329             lock (eflBindingEventLock)
 330             {
 331                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 332                 {
 333                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 334                     if (obj != null)
 335                     {
 336                         Efl.Canvas.ISceneObjectFocusInEvt_Args args = new Efl.Canvas.ISceneObjectFocusInEvt_Args();
 337                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
 338                         try
 339                         {
 340                             value?.Invoke(obj, args);
 341                         }
 342                         catch (Exception e)
 343                         {
 344                             Eina.Log.Error(e.ToString());
 345                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 346                         }
 347                     }
 348                 };
 349
 350                 string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
 351                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 352             }
 353         }
 354
 355         remove
 356         {
 357             lock (eflBindingEventLock)
 358             {
 359                 string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
 360                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 361             }
 362         }
 363     }
 364     ///<summary>Method to raise event ObjectFocusInEvt.</summary>
 365     public void OnObjectFocusInEvt(Efl.Canvas.ISceneObjectFocusInEvt_Args e)
 366     {
 367         var key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
 368         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 369         if (desc == IntPtr.Zero)
 370         {
 371             Eina.Log.Error($"Failed to get native event {key}");
 372             return;
 373         }
 374
 375         IntPtr info = e.arg.NativeHandle;
 376         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 377     }
 378     /// <summary>Called when object lost focus
 379     /// (Since EFL 1.22)</summary>
 380     public event EventHandler<Efl.Canvas.ISceneObjectFocusOutEvt_Args> ObjectFocusOutEvt
 381     {
 382         add
 383         {
 384             lock (eflBindingEventLock)
 385             {
 386                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 387                 {
 388                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 389                     if (obj != null)
 390                     {
 391                         Efl.Canvas.ISceneObjectFocusOutEvt_Args args = new Efl.Canvas.ISceneObjectFocusOutEvt_Args();
 392                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
 393                         try
 394                         {
 395                             value?.Invoke(obj, args);
 396                         }
 397                         catch (Exception e)
 398                         {
 399                             Eina.Log.Error(e.ToString());
 400                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 401                         }
 402                     }
 403                 };
 404
 405                 string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
 406                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 407             }
 408         }
 409
 410         remove
 411         {
 412             lock (eflBindingEventLock)
 413             {
 414                 string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
 415                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 416             }
 417         }
 418     }
 419     ///<summary>Method to raise event ObjectFocusOutEvt.</summary>
 420     public void OnObjectFocusOutEvt(Efl.Canvas.ISceneObjectFocusOutEvt_Args e)
 421     {
 422         var key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
 423         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 424         if (desc == IntPtr.Zero)
 425         {
 426             Eina.Log.Error($"Failed to get native event {key}");
 427             return;
 428         }
 429
 430         IntPtr info = e.arg.NativeHandle;
 431         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 432     }
 433     /// <summary>Called when pre render happens
 434     /// (Since EFL 1.22)</summary>
 435     public event EventHandler RenderPreEvt
 436     {
 437         add
 438         {
 439             lock (eflBindingEventLock)
 440             {
 441                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 442                 {
 443                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 444                     if (obj != null)
 445                     {
 446                         EventArgs args = EventArgs.Empty;
 447                         try
 448                         {
 449                             value?.Invoke(obj, args);
 450                         }
 451                         catch (Exception e)
 452                         {
 453                             Eina.Log.Error(e.ToString());
 454                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 455                         }
 456                     }
 457                 };
 458
 459                 string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
 460                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 461             }
 462         }
 463
 464         remove
 465         {
 466             lock (eflBindingEventLock)
 467             {
 468                 string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
 469                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 470             }
 471         }
 472     }
 473     ///<summary>Method to raise event RenderPreEvt.</summary>
 474     public void OnRenderPreEvt(EventArgs e)
 475     {
 476         var key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
 477         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 478         if (desc == IntPtr.Zero)
 479         {
 480             Eina.Log.Error($"Failed to get native event {key}");
 481             return;
 482         }
 483
 484         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 485     }
 486     /// <summary>Called when post render happens
 487     /// (Since EFL 1.22)</summary>
 488     public event EventHandler<Efl.Canvas.ISceneRenderPostEvt_Args> RenderPostEvt
 489     {
 490         add
 491         {
 492             lock (eflBindingEventLock)
 493             {
 494                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 495                 {
 496                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 497                     if (obj != null)
 498                     {
 499                         Efl.Canvas.ISceneRenderPostEvt_Args args = new Efl.Canvas.ISceneRenderPostEvt_Args();
 500                         args.arg =  evt.Info;
 501                         try
 502                         {
 503                             value?.Invoke(obj, args);
 504                         }
 505                         catch (Exception e)
 506                         {
 507                             Eina.Log.Error(e.ToString());
 508                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 509                         }
 510                     }
 511                 };
 512
 513                 string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
 514                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 515             }
 516         }
 517
 518         remove
 519         {
 520             lock (eflBindingEventLock)
 521             {
 522                 string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
 523                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 524             }
 525         }
 526     }
 527     ///<summary>Method to raise event RenderPostEvt.</summary>
 528     public void OnRenderPostEvt(Efl.Canvas.ISceneRenderPostEvt_Args e)
 529     {
 530         var key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
 531         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 532         if (desc == IntPtr.Zero)
 533         {
 534             Eina.Log.Error($"Failed to get native event {key}");
 535             return;
 536         }
 537
 538         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 539         try
 540         {
 541             Marshal.StructureToPtr(e.arg, info, false);
 542             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 543         }
 544         finally
 545         {
 546             Marshal.FreeHGlobal(info);
 547         }
 548     }
 549     /// <summary>Called when input device changed
 550     /// (Since EFL 1.22)</summary>
 551     public event EventHandler<Efl.Canvas.ISceneDeviceChangedEvt_Args> DeviceChangedEvt
 552     {
 553         add
 554         {
 555             lock (eflBindingEventLock)
 556             {
 557                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 558                 {
 559                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 560                     if (obj != null)
 561                     {
 562                         Efl.Canvas.ISceneDeviceChangedEvt_Args args = new Efl.Canvas.ISceneDeviceChangedEvt_Args();
 563                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Device);
 564                         try
 565                         {
 566                             value?.Invoke(obj, args);
 567                         }
 568                         catch (Exception e)
 569                         {
 570                             Eina.Log.Error(e.ToString());
 571                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 572                         }
 573                     }
 574                 };
 575
 576                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
 577                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 578             }
 579         }
 580
 581         remove
 582         {
 583             lock (eflBindingEventLock)
 584             {
 585                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
 586                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 587             }
 588         }
 589     }
 590     ///<summary>Method to raise event DeviceChangedEvt.</summary>
 591     public void OnDeviceChangedEvt(Efl.Canvas.ISceneDeviceChangedEvt_Args e)
 592     {
 593         var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
 594         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 595         if (desc == IntPtr.Zero)
 596         {
 597             Eina.Log.Error($"Failed to get native event {key}");
 598             return;
 599         }
 600
 601         IntPtr info = e.arg.NativeHandle;
 602         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 603     }
 604     /// <summary>Called when input device was added
 605     /// (Since EFL 1.22)</summary>
 606     public event EventHandler<Efl.Canvas.ISceneDeviceAddedEvt_Args> DeviceAddedEvt
 607     {
 608         add
 609         {
 610             lock (eflBindingEventLock)
 611             {
 612                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 613                 {
 614                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 615                     if (obj != null)
 616                     {
 617                         Efl.Canvas.ISceneDeviceAddedEvt_Args args = new Efl.Canvas.ISceneDeviceAddedEvt_Args();
 618                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Device);
 619                         try
 620                         {
 621                             value?.Invoke(obj, args);
 622                         }
 623                         catch (Exception e)
 624                         {
 625                             Eina.Log.Error(e.ToString());
 626                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 627                         }
 628                     }
 629                 };
 630
 631                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
 632                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 633             }
 634         }
 635
 636         remove
 637         {
 638             lock (eflBindingEventLock)
 639             {
 640                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
 641                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 642             }
 643         }
 644     }
 645     ///<summary>Method to raise event DeviceAddedEvt.</summary>
 646     public void OnDeviceAddedEvt(Efl.Canvas.ISceneDeviceAddedEvt_Args e)
 647     {
 648         var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
 649         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 650         if (desc == IntPtr.Zero)
 651         {
 652             Eina.Log.Error($"Failed to get native event {key}");
 653             return;
 654         }
 655
 656         IntPtr info = e.arg.NativeHandle;
 657         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 658     }
 659     /// <summary>Called when input device was removed
 660     /// (Since EFL 1.22)</summary>
 661     public event EventHandler<Efl.Canvas.ISceneDeviceRemovedEvt_Args> DeviceRemovedEvt
 662     {
 663         add
 664         {
 665             lock (eflBindingEventLock)
 666             {
 667                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 668                 {
 669                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 670                     if (obj != null)
 671                     {
 672                         Efl.Canvas.ISceneDeviceRemovedEvt_Args args = new Efl.Canvas.ISceneDeviceRemovedEvt_Args();
 673                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Device);
 674                         try
 675                         {
 676                             value?.Invoke(obj, args);
 677                         }
 678                         catch (Exception e)
 679                         {
 680                             Eina.Log.Error(e.ToString());
 681                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 682                         }
 683                     }
 684                 };
 685
 686                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
 687                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 688             }
 689         }
 690
 691         remove
 692         {
 693             lock (eflBindingEventLock)
 694             {
 695                 string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
 696                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 697             }
 698         }
 699     }
 700     ///<summary>Method to raise event DeviceRemovedEvt.</summary>
 701     public void OnDeviceRemovedEvt(Efl.Canvas.ISceneDeviceRemovedEvt_Args e)
 702     {
 703         var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
 704         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 705         if (desc == IntPtr.Zero)
 706         {
 707             Eina.Log.Error($"Failed to get native event {key}");
 708             return;
 709         }
 710
 711         IntPtr info = e.arg.NativeHandle;
 712         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 713     }
 714     /// <summary>Get the maximum image size the canvas can possibly handle.
 715     /// This function returns the largest image or surface size that the canvas can handle in pixels, and if there is one, returns <c>true</c>. It returns <c>false</c> if no extra constraint on maximum image size exists.
 716     ///
 717     /// The default limit is 65535x65535.
 718     /// (Since EFL 1.22)</summary>
 719     /// <param name="max">The maximum image size (in pixels).</param>
 720     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 721     public bool GetImageMaxSize(out Eina.Size2D max) {
 722                  var _out_max = new Eina.Size2D.NativeStruct();
 723                 var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_image_max_size_get_ptr.Value.Delegate(this.NativeHandle,out _out_max);
 724         Eina.Error.RaiseIfUnhandledException();
 725         max = _out_max;
 726                 return _ret_var;
 727  }
 728     /// <summary>Get if the canvas is currently calculating group objects.
 729     /// (Since EFL 1.22)</summary>
 730     /// <returns><c>true</c> if currently calculating group objects.</returns>
 731     public bool GetGroupObjectsCalculating() {
 732          var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_group_objects_calculating_get_ptr.Value.Delegate(this.NativeHandle);
 733         Eina.Error.RaiseIfUnhandledException();
 734         return _ret_var;
 735  }
 736     /// <summary>Get a device by name.
 737     /// (Since EFL 1.22)</summary>
 738     /// <param name="name">The name of the seat to find.</param>
 739     /// <returns>The device or seat, <c>null</c> if not found.</returns>
 740     public Efl.Input.Device GetDevice(System.String name) {
 741                                  var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_device_get_ptr.Value.Delegate(this.NativeHandle,name);
 742         Eina.Error.RaiseIfUnhandledException();
 743                         return _ret_var;
 744  }
 745     /// <summary>Get a seat by id.
 746     /// (Since EFL 1.22)</summary>
 747     /// <param name="id">The id of the seat to find.</param>
 748     /// <returns>The seat or <c>null</c> if not found.</returns>
 749     public Efl.Input.Device GetSeat(int id) {
 750                                  var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_seat_get_ptr.Value.Delegate(this.NativeHandle,id);
 751         Eina.Error.RaiseIfUnhandledException();
 752                         return _ret_var;
 753  }
 754     /// <summary>Get the default seat.
 755     /// (Since EFL 1.22)</summary>
 756     /// <returns>The default seat or <c>null</c> if one does not exist.</returns>
 757     public Efl.Input.Device GetSeatDefault() {
 758          var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_seat_default_get_ptr.Value.Delegate(this.NativeHandle);
 759         Eina.Error.RaiseIfUnhandledException();
 760         return _ret_var;
 761  }
 762     /// <summary>This function returns the current known pointer coordinates
 763     /// This function returns the current position of the main input pointer (mouse, pen, etc...).
 764     /// (Since EFL 1.22)</summary>
 765     /// <param name="seat">The seat, or <c>null</c> to use the default.</param>
 766     /// <param name="pos">The pointer position in pixels.</param>
 767     /// <returns><c>true</c> if a pointer exists for the given seat, otherwise <c>false</c>.</returns>
 768     public bool GetPointerPosition(Efl.Input.Device seat, out Eina.Position2D pos) {
 769                                  var _out_pos = new Eina.Position2D.NativeStruct();
 770                         var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_pointer_position_get_ptr.Value.Delegate(this.NativeHandle,seat, out _out_pos);
 771         Eina.Error.RaiseIfUnhandledException();
 772                 pos = _out_pos;
 773                         return _ret_var;
 774  }
 775     /// <summary>Call user-provided <c>calculate</c> group functions and unset the flag signalling that the object needs to get recalculated to all group objects in the canvas.
 776     /// (Since EFL 1.22)</summary>
 777     public void CalculateGroupObjects() {
 778          Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_group_objects_calculate_ptr.Value.Delegate(this.NativeHandle);
 779         Eina.Error.RaiseIfUnhandledException();
 780          }
 781     /// <summary>Retrieve a list of objects at a given position in a canvas.
 782     /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas covering the given position. The user can exclude from the query objects which are hidden and/or which are set to pass events.
 783     ///
 784     /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
 785     /// (Since EFL 1.22)</summary>
 786     /// <param name="pos">The pixel position.</param>
 787     /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
 788     /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
 789     /// <returns>The list of objects that are over the given position in <c>e</c>.</returns>
 790     public Eina.Iterator<Efl.Gfx.IEntity> GetObjectsAtXy(Eina.Position2D pos, bool include_pass_events_objects, bool include_hidden_objects) {
 791          Eina.Position2D.NativeStruct _in_pos = pos;
 792                                                                         var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_objects_at_xy_get_ptr.Value.Delegate(this.NativeHandle,_in_pos, include_pass_events_objects, include_hidden_objects);
 793         Eina.Error.RaiseIfUnhandledException();
 794                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true);
 795  }
 796     /// <summary>Retrieve the object stacked at the top of a given position in a canvas.
 797     /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas covering the given position. The user can exclude from the query objects which are hidden and/or which are set to pass events.
 798     ///
 799     /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
 800     /// (Since EFL 1.22)</summary>
 801     /// <param name="pos">The pixel position.</param>
 802     /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
 803     /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
 804     /// <returns>The canvas object that is over all other objects at the given position.</returns>
 805     public Efl.Gfx.IEntity GetObjectTopAtXy(Eina.Position2D pos, bool include_pass_events_objects, bool include_hidden_objects) {
 806          Eina.Position2D.NativeStruct _in_pos = pos;
 807                                                                         var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_object_top_at_xy_get_ptr.Value.Delegate(this.NativeHandle,_in_pos, include_pass_events_objects, include_hidden_objects);
 808         Eina.Error.RaiseIfUnhandledException();
 809                                                         return _ret_var;
 810  }
 811     /// <summary>Retrieve a list of objects overlapping a given rectangular region in a canvas.
 812     /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas overlapping with the given rectangular region. The user can exclude from the query objects which are hidden and/or which are set to pass events.
 813     ///
 814     /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
 815     /// (Since EFL 1.22)</summary>
 816     /// <param name="rect">The rectangular region.</param>
 817     /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
 818     /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
 819     /// <returns>Iterator to objects</returns>
 820     public Eina.Iterator<Efl.Gfx.IEntity> GetObjectsInRectangle(Eina.Rect rect, bool include_pass_events_objects, bool include_hidden_objects) {
 821          Eina.Rect.NativeStruct _in_rect = rect;
 822                                                                         var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_objects_in_rectangle_get_ptr.Value.Delegate(this.NativeHandle,_in_rect, include_pass_events_objects, include_hidden_objects);
 823         Eina.Error.RaiseIfUnhandledException();
 824                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true);
 825  }
 826     /// <summary>Retrieve the canvas object stacked at the top of a given rectangular region in a canvas
 827     /// This function will traverse all the layers of the given canvas, from top to bottom, querying for objects with areas overlapping with the given rectangular region. The user can exclude from the query objects which are hidden and/or which are set to pass events.
 828     ///
 829     /// Warning: This function will only evaluate top-level objects; child or &quot;sub&quot; objects will be skipped.
 830     /// (Since EFL 1.22)</summary>
 831     /// <param name="rect">The rectangular region.</param>
 832     /// <param name="include_pass_events_objects">Boolean flag to include or not objects which pass events in this calculation.</param>
 833     /// <param name="include_hidden_objects">Boolean flag to include or not hidden objects in this calculation.</param>
 834     /// <returns>The object that is over all other objects at the given rectangular region.</returns>
 835     public Efl.Gfx.IEntity GetObjectTopInRectangle(Eina.Rect rect, bool include_pass_events_objects, bool include_hidden_objects) {
 836          Eina.Rect.NativeStruct _in_rect = rect;
 837                                                                         var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_object_top_in_rectangle_get_ptr.Value.Delegate(this.NativeHandle,_in_rect, include_pass_events_objects, include_hidden_objects);
 838         Eina.Error.RaiseIfUnhandledException();
 839                                                         return _ret_var;
 840  }
 841     /// <summary>Iterate over the available input device seats for the canvas.
 842     /// A &quot;seat&quot; is the term used for a group of input devices, typically including a pointer and a keyboard. A seat object is the parent of the individual input devices.
 843     /// (Since EFL 1.22)</summary>
 844     /// <returns>An iterator over the attached seats.</returns>
 845     public Eina.Iterator<Efl.Input.Device> Seats() {
 846          var _ret_var = Efl.Canvas.ISceneConcrete.NativeMethods.efl_canvas_scene_seats_ptr.Value.Delegate(this.NativeHandle);
 847         Eina.Error.RaiseIfUnhandledException();
 848         return new Eina.Iterator<Efl.Input.Device>(_ret_var, true);
 849  }
 850     /// <summary>Get if the canvas is currently calculating group objects.
 851     /// (Since EFL 1.22)</summary>
 852     /// <value><c>true</c> if currently calculating group objects.</value>
 853     public bool GroupObjectsCalculating {
 854         get { return GetGroupObjectsCalculating(); }
 855     }
 856     /// <summary>Get the default seat attached to this canvas.
 857     /// A canvas may have exactly one default seat.
 858     ///
 859     /// See also <see cref="Efl.Canvas.IScene.GetDevice"/> to find a seat by name. See also <see cref="Efl.Canvas.IScene.GetSeat"/> to find a seat by id.
 860     /// (Since EFL 1.22)</summary>
 861     /// <value>The default seat or <c>null</c> if one does not exist.</value>
 862     public Efl.Input.Device SeatDefault {
 863         get { return GetSeatDefault(); }
 864     }
 865     private static IntPtr GetEflClassStatic()
 866     {
 867         return Efl.Canvas.ISceneConcrete.efl_canvas_scene_interface_get();
 868     }
 869     /// <summary>Wrapper for native methods and virtual method delegates.
 870     /// For internal use by generated code only.</summary>
 871     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 872     {
 873         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 874         /// <summary>Gets the list of Eo operations to override.</summary>
 875         /// <returns>The list of Eo operations to be overload.</returns>
 876         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 877         {
 878             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 879             var methods = Efl.Eo.Globals.GetUserMethods(type);
 880
 881             if (efl_canvas_scene_image_max_size_get_static_delegate == null)
 882             {
 883                 efl_canvas_scene_image_max_size_get_static_delegate = new efl_canvas_scene_image_max_size_get_delegate(image_max_size_get);
 884             }
 885
 886             if (methods.FirstOrDefault(m => m.Name == "GetImageMaxSize") != null)
 887             {
 888                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_image_max_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_image_max_size_get_static_delegate) });
 889             }
 890
 891             if (efl_canvas_scene_group_objects_calculating_get_static_delegate == null)
 892             {
 893                 efl_canvas_scene_group_objects_calculating_get_static_delegate = new efl_canvas_scene_group_objects_calculating_get_delegate(group_objects_calculating_get);
 894             }
 895
 896             if (methods.FirstOrDefault(m => m.Name == "GetGroupObjectsCalculating") != null)
 897             {
 898                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_group_objects_calculating_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_group_objects_calculating_get_static_delegate) });
 899             }
 900
 901             if (efl_canvas_scene_device_get_static_delegate == null)
 902             {
 903                 efl_canvas_scene_device_get_static_delegate = new efl_canvas_scene_device_get_delegate(device_get);
 904             }
 905
 906             if (methods.FirstOrDefault(m => m.Name == "GetDevice") != null)
 907             {
 908                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_device_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_device_get_static_delegate) });
 909             }
 910
 911             if (efl_canvas_scene_seat_get_static_delegate == null)
 912             {
 913                 efl_canvas_scene_seat_get_static_delegate = new efl_canvas_scene_seat_get_delegate(seat_get);
 914             }
 915
 916             if (methods.FirstOrDefault(m => m.Name == "GetSeat") != null)
 917             {
 918                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_seat_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_seat_get_static_delegate) });
 919             }
 920
 921             if (efl_canvas_scene_seat_default_get_static_delegate == null)
 922             {
 923                 efl_canvas_scene_seat_default_get_static_delegate = new efl_canvas_scene_seat_default_get_delegate(seat_default_get);
 924             }
 925
 926             if (methods.FirstOrDefault(m => m.Name == "GetSeatDefault") != null)
 927             {
 928                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_seat_default_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_seat_default_get_static_delegate) });
 929             }
 930
 931             if (efl_canvas_scene_pointer_position_get_static_delegate == null)
 932             {
 933                 efl_canvas_scene_pointer_position_get_static_delegate = new efl_canvas_scene_pointer_position_get_delegate(pointer_position_get);
 934             }
 935
 936             if (methods.FirstOrDefault(m => m.Name == "GetPointerPosition") != null)
 937             {
 938                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_pointer_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_pointer_position_get_static_delegate) });
 939             }
 940
 941             if (efl_canvas_scene_group_objects_calculate_static_delegate == null)
 942             {
 943                 efl_canvas_scene_group_objects_calculate_static_delegate = new efl_canvas_scene_group_objects_calculate_delegate(group_objects_calculate);
 944             }
 945
 946             if (methods.FirstOrDefault(m => m.Name == "CalculateGroupObjects") != null)
 947             {
 948                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_group_objects_calculate"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_group_objects_calculate_static_delegate) });
 949             }
 950
 951             if (efl_canvas_scene_objects_at_xy_get_static_delegate == null)
 952             {
 953                 efl_canvas_scene_objects_at_xy_get_static_delegate = new efl_canvas_scene_objects_at_xy_get_delegate(objects_at_xy_get);
 954             }
 955
 956             if (methods.FirstOrDefault(m => m.Name == "GetObjectsAtXy") != null)
 957             {
 958                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_objects_at_xy_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_objects_at_xy_get_static_delegate) });
 959             }
 960
 961             if (efl_canvas_scene_object_top_at_xy_get_static_delegate == null)
 962             {
 963                 efl_canvas_scene_object_top_at_xy_get_static_delegate = new efl_canvas_scene_object_top_at_xy_get_delegate(object_top_at_xy_get);
 964             }
 965
 966             if (methods.FirstOrDefault(m => m.Name == "GetObjectTopAtXy") != null)
 967             {
 968                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_object_top_at_xy_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_object_top_at_xy_get_static_delegate) });
 969             }
 970
 971             if (efl_canvas_scene_objects_in_rectangle_get_static_delegate == null)
 972             {
 973                 efl_canvas_scene_objects_in_rectangle_get_static_delegate = new efl_canvas_scene_objects_in_rectangle_get_delegate(objects_in_rectangle_get);
 974             }
 975
 976             if (methods.FirstOrDefault(m => m.Name == "GetObjectsInRectangle") != null)
 977             {
 978                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_objects_in_rectangle_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_objects_in_rectangle_get_static_delegate) });
 979             }
 980
 981             if (efl_canvas_scene_object_top_in_rectangle_get_static_delegate == null)
 982             {
 983                 efl_canvas_scene_object_top_in_rectangle_get_static_delegate = new efl_canvas_scene_object_top_in_rectangle_get_delegate(object_top_in_rectangle_get);
 984             }
 985
 986             if (methods.FirstOrDefault(m => m.Name == "GetObjectTopInRectangle") != null)
 987             {
 988                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_object_top_in_rectangle_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_object_top_in_rectangle_get_static_delegate) });
 989             }
 990
 991             if (efl_canvas_scene_seats_static_delegate == null)
 992             {
 993                 efl_canvas_scene_seats_static_delegate = new efl_canvas_scene_seats_delegate(seats);
 994             }
 995
 996             if (methods.FirstOrDefault(m => m.Name == "Seats") != null)
 997             {
 998                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_scene_seats"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_scene_seats_static_delegate) });
 999             }
1000
1001             return descs;
1002         }
1003         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1004         /// <returns>The native class pointer.</returns>
1005         public override IntPtr GetEflClass()
1006         {
1007             return Efl.Canvas.ISceneConcrete.efl_canvas_scene_interface_get();
1008         }
1009
1010         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1011
1012         [return: MarshalAs(UnmanagedType.U1)]
1013         private delegate bool efl_canvas_scene_image_max_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out Eina.Size2D.NativeStruct max);
1014
1015         [return: MarshalAs(UnmanagedType.U1)]
1016         public delegate bool efl_canvas_scene_image_max_size_get_api_delegate(System.IntPtr obj,  out Eina.Size2D.NativeStruct max);
1017
1018         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_image_max_size_get_api_delegate> efl_canvas_scene_image_max_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_image_max_size_get_api_delegate>(Module, "efl_canvas_scene_image_max_size_get");
1019
1020         private static bool image_max_size_get(System.IntPtr obj, System.IntPtr pd, out Eina.Size2D.NativeStruct max)
1021         {
1022             Eina.Log.Debug("function efl_canvas_scene_image_max_size_get was called");
1023             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1024             if (ws != null)
1025             {
1026                 Eina.Size2D _out_max = default(Eina.Size2D);
1027                     bool _ret_var = default(bool);
1028                 try
1029                 {
1030                     _ret_var = ((IScene)ws.Target).GetImageMaxSize(out _out_max);
1031                 }
1032                 catch (Exception e)
1033                 {
1034                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1035                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1036                 }
1037
1038         max = _out_max;
1039                 return _ret_var;
1040
1041             }
1042             else
1043             {
1044                 return efl_canvas_scene_image_max_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out max);
1045             }
1046         }
1047
1048         private static efl_canvas_scene_image_max_size_get_delegate efl_canvas_scene_image_max_size_get_static_delegate;
1049
1050         [return: MarshalAs(UnmanagedType.U1)]
1051         private delegate bool efl_canvas_scene_group_objects_calculating_get_delegate(System.IntPtr obj, System.IntPtr pd);
1052
1053         [return: MarshalAs(UnmanagedType.U1)]
1054         public delegate bool efl_canvas_scene_group_objects_calculating_get_api_delegate(System.IntPtr obj);
1055
1056         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_group_objects_calculating_get_api_delegate> efl_canvas_scene_group_objects_calculating_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_group_objects_calculating_get_api_delegate>(Module, "efl_canvas_scene_group_objects_calculating_get");
1057
1058         private static bool group_objects_calculating_get(System.IntPtr obj, System.IntPtr pd)
1059         {
1060             Eina.Log.Debug("function efl_canvas_scene_group_objects_calculating_get was called");
1061             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1062             if (ws != null)
1063             {
1064             bool _ret_var = default(bool);
1065                 try
1066                 {
1067                     _ret_var = ((IScene)ws.Target).GetGroupObjectsCalculating();
1068                 }
1069                 catch (Exception e)
1070                 {
1071                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1072                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1073                 }
1074
1075         return _ret_var;
1076
1077             }
1078             else
1079             {
1080                 return efl_canvas_scene_group_objects_calculating_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1081             }
1082         }
1083
1084         private static efl_canvas_scene_group_objects_calculating_get_delegate efl_canvas_scene_group_objects_calculating_get_static_delegate;
1085
1086         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1087         private delegate Efl.Input.Device efl_canvas_scene_device_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
1088
1089         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1090         public delegate Efl.Input.Device efl_canvas_scene_device_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
1091
1092         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_device_get_api_delegate> efl_canvas_scene_device_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_device_get_api_delegate>(Module, "efl_canvas_scene_device_get");
1093
1094         private static Efl.Input.Device device_get(System.IntPtr obj, System.IntPtr pd, System.String name)
1095         {
1096             Eina.Log.Debug("function efl_canvas_scene_device_get was called");
1097             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1098             if (ws != null)
1099             {
1100                                     Efl.Input.Device _ret_var = default(Efl.Input.Device);
1101                 try
1102                 {
1103                     _ret_var = ((IScene)ws.Target).GetDevice(name);
1104                 }
1105                 catch (Exception e)
1106                 {
1107                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1108                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1109                 }
1110
1111                         return _ret_var;
1112
1113             }
1114             else
1115             {
1116                 return efl_canvas_scene_device_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
1117             }
1118         }
1119
1120         private static efl_canvas_scene_device_get_delegate efl_canvas_scene_device_get_static_delegate;
1121
1122         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1123         private delegate Efl.Input.Device efl_canvas_scene_seat_get_delegate(System.IntPtr obj, System.IntPtr pd,  int id);
1124
1125         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1126         public delegate Efl.Input.Device efl_canvas_scene_seat_get_api_delegate(System.IntPtr obj,  int id);
1127
1128         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_seat_get_api_delegate> efl_canvas_scene_seat_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_seat_get_api_delegate>(Module, "efl_canvas_scene_seat_get");
1129
1130         private static Efl.Input.Device seat_get(System.IntPtr obj, System.IntPtr pd, int id)
1131         {
1132             Eina.Log.Debug("function efl_canvas_scene_seat_get was called");
1133             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1134             if (ws != null)
1135             {
1136                                     Efl.Input.Device _ret_var = default(Efl.Input.Device);
1137                 try
1138                 {
1139                     _ret_var = ((IScene)ws.Target).GetSeat(id);
1140                 }
1141                 catch (Exception e)
1142                 {
1143                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1144                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1145                 }
1146
1147                         return _ret_var;
1148
1149             }
1150             else
1151             {
1152                 return efl_canvas_scene_seat_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id);
1153             }
1154         }
1155
1156         private static efl_canvas_scene_seat_get_delegate efl_canvas_scene_seat_get_static_delegate;
1157
1158         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1159         private delegate Efl.Input.Device efl_canvas_scene_seat_default_get_delegate(System.IntPtr obj, System.IntPtr pd);
1160
1161         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1162         public delegate Efl.Input.Device efl_canvas_scene_seat_default_get_api_delegate(System.IntPtr obj);
1163
1164         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_seat_default_get_api_delegate> efl_canvas_scene_seat_default_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_seat_default_get_api_delegate>(Module, "efl_canvas_scene_seat_default_get");
1165
1166         private static Efl.Input.Device seat_default_get(System.IntPtr obj, System.IntPtr pd)
1167         {
1168             Eina.Log.Debug("function efl_canvas_scene_seat_default_get was called");
1169             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1170             if (ws != null)
1171             {
1172             Efl.Input.Device _ret_var = default(Efl.Input.Device);
1173                 try
1174                 {
1175                     _ret_var = ((IScene)ws.Target).GetSeatDefault();
1176                 }
1177                 catch (Exception e)
1178                 {
1179                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1180                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1181                 }
1182
1183         return _ret_var;
1184
1185             }
1186             else
1187             {
1188                 return efl_canvas_scene_seat_default_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1189             }
1190         }
1191
1192         private static efl_canvas_scene_seat_default_get_delegate efl_canvas_scene_seat_default_get_static_delegate;
1193
1194         [return: MarshalAs(UnmanagedType.U1)]
1195         private delegate bool efl_canvas_scene_pointer_position_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat,  out Eina.Position2D.NativeStruct pos);
1196
1197         [return: MarshalAs(UnmanagedType.U1)]
1198         public delegate bool efl_canvas_scene_pointer_position_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat,  out Eina.Position2D.NativeStruct pos);
1199
1200         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_pointer_position_get_api_delegate> efl_canvas_scene_pointer_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_pointer_position_get_api_delegate>(Module, "efl_canvas_scene_pointer_position_get");
1201
1202         private static bool pointer_position_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Device seat, out Eina.Position2D.NativeStruct pos)
1203         {
1204             Eina.Log.Debug("function efl_canvas_scene_pointer_position_get was called");
1205             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1206             if (ws != null)
1207             {
1208                                 Eina.Position2D _out_pos = default(Eina.Position2D);
1209                             bool _ret_var = default(bool);
1210                 try
1211                 {
1212                     _ret_var = ((IScene)ws.Target).GetPointerPosition(seat, out _out_pos);
1213                 }
1214                 catch (Exception e)
1215                 {
1216                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1217                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1218                 }
1219
1220                 pos = _out_pos;
1221                         return _ret_var;
1222
1223             }
1224             else
1225             {
1226                 return efl_canvas_scene_pointer_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), seat, out pos);
1227             }
1228         }
1229
1230         private static efl_canvas_scene_pointer_position_get_delegate efl_canvas_scene_pointer_position_get_static_delegate;
1231
1232
1233         private delegate void efl_canvas_scene_group_objects_calculate_delegate(System.IntPtr obj, System.IntPtr pd);
1234
1235
1236         public delegate void efl_canvas_scene_group_objects_calculate_api_delegate(System.IntPtr obj);
1237
1238         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_group_objects_calculate_api_delegate> efl_canvas_scene_group_objects_calculate_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_group_objects_calculate_api_delegate>(Module, "efl_canvas_scene_group_objects_calculate");
1239
1240         private static void group_objects_calculate(System.IntPtr obj, System.IntPtr pd)
1241         {
1242             Eina.Log.Debug("function efl_canvas_scene_group_objects_calculate was called");
1243             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1244             if (ws != null)
1245             {
1246
1247                 try
1248                 {
1249                     ((IScene)ws.Target).CalculateGroupObjects();
1250                 }
1251                 catch (Exception e)
1252                 {
1253                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1254                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1255                 }
1256
1257
1258             }
1259             else
1260             {
1261                 efl_canvas_scene_group_objects_calculate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1262             }
1263         }
1264
1265         private static efl_canvas_scene_group_objects_calculate_delegate efl_canvas_scene_group_objects_calculate_static_delegate;
1266
1267
1268         private delegate System.IntPtr efl_canvas_scene_objects_at_xy_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1269
1270
1271         public delegate System.IntPtr efl_canvas_scene_objects_at_xy_get_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1272
1273         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_objects_at_xy_get_api_delegate> efl_canvas_scene_objects_at_xy_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_objects_at_xy_get_api_delegate>(Module, "efl_canvas_scene_objects_at_xy_get");
1274
1275         private static System.IntPtr objects_at_xy_get(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos, bool include_pass_events_objects, bool include_hidden_objects)
1276         {
1277             Eina.Log.Debug("function efl_canvas_scene_objects_at_xy_get was called");
1278             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1279             if (ws != null)
1280             {
1281         Eina.Position2D _in_pos = pos;
1282                                                                             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1283                 try
1284                 {
1285                     _ret_var = ((IScene)ws.Target).GetObjectsAtXy(_in_pos, include_pass_events_objects, include_hidden_objects);
1286                 }
1287                 catch (Exception e)
1288                 {
1289                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1290                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1291                 }
1292
1293                                                         _ret_var.Own = false; return _ret_var.Handle;
1294
1295             }
1296             else
1297             {
1298                 return efl_canvas_scene_objects_at_xy_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos, include_pass_events_objects, include_hidden_objects);
1299             }
1300         }
1301
1302         private static efl_canvas_scene_objects_at_xy_get_delegate efl_canvas_scene_objects_at_xy_get_static_delegate;
1303
1304         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1305         private delegate Efl.Gfx.IEntity efl_canvas_scene_object_top_at_xy_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1306
1307         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1308         public delegate Efl.Gfx.IEntity efl_canvas_scene_object_top_at_xy_get_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1309
1310         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_object_top_at_xy_get_api_delegate> efl_canvas_scene_object_top_at_xy_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_object_top_at_xy_get_api_delegate>(Module, "efl_canvas_scene_object_top_at_xy_get");
1311
1312         private static Efl.Gfx.IEntity object_top_at_xy_get(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos, bool include_pass_events_objects, bool include_hidden_objects)
1313         {
1314             Eina.Log.Debug("function efl_canvas_scene_object_top_at_xy_get was called");
1315             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1316             if (ws != null)
1317             {
1318         Eina.Position2D _in_pos = pos;
1319                                                                             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1320                 try
1321                 {
1322                     _ret_var = ((IScene)ws.Target).GetObjectTopAtXy(_in_pos, include_pass_events_objects, include_hidden_objects);
1323                 }
1324                 catch (Exception e)
1325                 {
1326                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1327                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1328                 }
1329
1330                                                         return _ret_var;
1331
1332             }
1333             else
1334             {
1335                 return efl_canvas_scene_object_top_at_xy_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos, include_pass_events_objects, include_hidden_objects);
1336             }
1337         }
1338
1339         private static efl_canvas_scene_object_top_at_xy_get_delegate efl_canvas_scene_object_top_at_xy_get_static_delegate;
1340
1341
1342         private delegate System.IntPtr efl_canvas_scene_objects_in_rectangle_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1343
1344
1345         public delegate System.IntPtr efl_canvas_scene_objects_in_rectangle_get_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1346
1347         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_objects_in_rectangle_get_api_delegate> efl_canvas_scene_objects_in_rectangle_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_objects_in_rectangle_get_api_delegate>(Module, "efl_canvas_scene_objects_in_rectangle_get");
1348
1349         private static System.IntPtr objects_in_rectangle_get(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect, bool include_pass_events_objects, bool include_hidden_objects)
1350         {
1351             Eina.Log.Debug("function efl_canvas_scene_objects_in_rectangle_get was called");
1352             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1353             if (ws != null)
1354             {
1355         Eina.Rect _in_rect = rect;
1356                                                                             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1357                 try
1358                 {
1359                     _ret_var = ((IScene)ws.Target).GetObjectsInRectangle(_in_rect, include_pass_events_objects, include_hidden_objects);
1360                 }
1361                 catch (Exception e)
1362                 {
1363                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1364                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1365                 }
1366
1367                                                         _ret_var.Own = false; return _ret_var.Handle;
1368
1369             }
1370             else
1371             {
1372                 return efl_canvas_scene_objects_in_rectangle_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect, include_pass_events_objects, include_hidden_objects);
1373             }
1374         }
1375
1376         private static efl_canvas_scene_objects_in_rectangle_get_delegate efl_canvas_scene_objects_in_rectangle_get_static_delegate;
1377
1378         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1379         private delegate Efl.Gfx.IEntity efl_canvas_scene_object_top_in_rectangle_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1380
1381         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1382         public delegate Efl.Gfx.IEntity efl_canvas_scene_object_top_in_rectangle_get_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool include_pass_events_objects, [MarshalAs(UnmanagedType.U1)] bool include_hidden_objects);
1383
1384         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_object_top_in_rectangle_get_api_delegate> efl_canvas_scene_object_top_in_rectangle_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_object_top_in_rectangle_get_api_delegate>(Module, "efl_canvas_scene_object_top_in_rectangle_get");
1385
1386         private static Efl.Gfx.IEntity object_top_in_rectangle_get(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect, bool include_pass_events_objects, bool include_hidden_objects)
1387         {
1388             Eina.Log.Debug("function efl_canvas_scene_object_top_in_rectangle_get was called");
1389             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1390             if (ws != null)
1391             {
1392         Eina.Rect _in_rect = rect;
1393                                                                             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1394                 try
1395                 {
1396                     _ret_var = ((IScene)ws.Target).GetObjectTopInRectangle(_in_rect, include_pass_events_objects, include_hidden_objects);
1397                 }
1398                 catch (Exception e)
1399                 {
1400                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1401                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1402                 }
1403
1404                                                         return _ret_var;
1405
1406             }
1407             else
1408             {
1409                 return efl_canvas_scene_object_top_in_rectangle_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect, include_pass_events_objects, include_hidden_objects);
1410             }
1411         }
1412
1413         private static efl_canvas_scene_object_top_in_rectangle_get_delegate efl_canvas_scene_object_top_in_rectangle_get_static_delegate;
1414
1415
1416         private delegate System.IntPtr efl_canvas_scene_seats_delegate(System.IntPtr obj, System.IntPtr pd);
1417
1418
1419         public delegate System.IntPtr efl_canvas_scene_seats_api_delegate(System.IntPtr obj);
1420
1421         public static Efl.Eo.FunctionWrapper<efl_canvas_scene_seats_api_delegate> efl_canvas_scene_seats_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_scene_seats_api_delegate>(Module, "efl_canvas_scene_seats");
1422
1423         private static System.IntPtr seats(System.IntPtr obj, System.IntPtr pd)
1424         {
1425             Eina.Log.Debug("function efl_canvas_scene_seats was called");
1426             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1427             if (ws != null)
1428             {
1429             Eina.Iterator<Efl.Input.Device> _ret_var = default(Eina.Iterator<Efl.Input.Device>);
1430                 try
1431                 {
1432                     _ret_var = ((IScene)ws.Target).Seats();
1433                 }
1434                 catch (Exception e)
1435                 {
1436                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1437                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1438                 }
1439
1440         _ret_var.Own = false; return _ret_var.Handle;
1441
1442             }
1443             else
1444             {
1445                 return efl_canvas_scene_seats_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1446             }
1447         }
1448
1449         private static efl_canvas_scene_seats_delegate efl_canvas_scene_seats_static_delegate;
1450
1451         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1452
1453 }
1454 }
1455 }
1456
1457 }
1458