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

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