internals/src/EflSharp/EflSharp/efl_ui_focus_object.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Ui { namespace Focus {
   8 /// <summary>Functions of focusable objects.
   9 /// 1.20</summary>
  10 [ObjectNativeInherit]
  11 public interface Object :
  12    Efl.Eo.IWrapper, IDisposable
  13 {
  14    /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
  15 /// 1.20</summary>
  16 /// <returns>The geometry to use.
  17 /// 1.20</returns>
  18 Eina.Rect GetFocusGeometry();
  19    /// <summary>Returns whether the widget is currently focused or not.
  20 /// 1.20</summary>
  21 /// <returns>The focused state of the object.
  22 /// 1.20</returns>
  23 bool GetFocus();
  24    /// <summary>This is called by the manager and should never be called by anyone else.
  25 /// The function emits the focus state events, if focus is different to the previous state.
  26 /// 1.20</summary>
  27 /// <param name="focus">The focused state of the object.
  28 /// 1.20</param>
  29 /// <returns></returns>
  30  void SetFocus( bool focus);
  31    /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
  32 /// 1.20</summary>
  33 /// <returns>The manager object
  34 /// 1.20</returns>
  35 Efl.Ui.Focus.Manager GetFocusManager();
  36    /// <summary>Describes which logical parent is used by this object.
  37 /// 1.20</summary>
  38 /// <returns>The focus parent.
  39 /// 1.20</returns>
  40 Efl.Ui.Focus.Object GetFocusParent();
  41    /// <summary>Indicates if a child of this object has focus set to true.
  42 /// 1.20</summary>
  43 /// <returns><c>true</c> if a child has focus.
  44 /// 1.20</returns>
  45 bool GetChildFocus();
  46    /// <summary>Indicates if a child of this object has focus set to true.
  47 /// 1.20</summary>
  48 /// <param name="child_focus"><c>true</c> if a child has focus.
  49 /// 1.20</param>
  50 /// <returns></returns>
  51  void SetChildFocus( bool child_focus);
  52    /// <summary>Tells the object that its children will be queried soon by the focus manager. Overwrite this to update the order of the children. Deleting items in this call will result in undefined behaviour and may cause your system to crash.
  53 /// 1.20</summary>
  54 /// <returns></returns>
  55  void SetupOrder();
  56    /// <summary>This is called when <see cref="Efl.Ui.Focus.Object.SetupOrder"/> is called, but only on the first call, additional recursive calls to <see cref="Efl.Ui.Focus.Object.SetupOrder"/> will not call this function again.
  57 /// 1.20</summary>
  58 /// <returns></returns>
  59  void SetupOrderNonRecursive();
  60    /// <summary>Virtual function handling focus in/out events on the widget
  61 /// 1.20</summary>
  62 /// <returns><c>true</c> if this widget can handle focus, <c>false</c> otherwise
  63 /// 1.20</returns>
  64 bool UpdateOnFocus();
  65                                  /// <summary>Emitted if the focus state has changed.
  66    /// 1.20</summary>
  67    event EventHandler<Efl.Ui.Focus.ObjectFocusChangedEvt_Args> FocusChangedEvt;
  68    /// <summary>Emitted when a new manager is the parent for this object.
  69    /// 1.20</summary>
  70    event EventHandler<Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args> Focus_managerChangedEvt;
  71    /// <summary>Emitted when a new logical parent should be used.
  72    /// 1.20</summary>
  73    event EventHandler<Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args> Focus_parentChangedEvt;
  74    /// <summary>Emitted if child_focus has changed.
  75    /// 1.20</summary>
  76    event EventHandler<Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args> Child_focusChangedEvt;
  77    /// <summary>Emitted if focus geometry of this object has changed.
  78    /// 1.20</summary>
  79    event EventHandler Focus_geometryChangedEvt;
  80    /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
  81 /// 1.20</summary>
  82 /// <value>The geometry to use.
  83 /// 1.20</value>
  84    Eina.Rect FocusGeometry {
  85       get ;
  86    }
  87    /// <summary>Returns whether the widget is currently focused or not.
  88 /// 1.20</summary>
  89 /// <value>The focused state of the object.
  90 /// 1.20</value>
  91    bool Focus {
  92       get ;
  93       set ;
  94    }
  95    /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
  96 /// 1.20</summary>
  97 /// <value>The manager object
  98 /// 1.20</value>
  99    Efl.Ui.Focus.Manager FocusManager {
 100       get ;
 101    }
 102    /// <summary>Describes which logical parent is used by this object.
 103 /// 1.20</summary>
 104 /// <value>The focus parent.
 105 /// 1.20</value>
 106    Efl.Ui.Focus.Object FocusParent {
 107       get ;
 108    }
 109    /// <summary>Indicates if a child of this object has focus set to true.
 110 /// 1.20</summary>
 111 /// <value><c>true</c> if a child has focus.
 112 /// 1.20</value>
 113    bool ChildFocus {
 114       get ;
 115       set ;
 116    }
 117 }
 118 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Focus.Object.FocusChangedEvt"/>.</summary>
 119 public class ObjectFocusChangedEvt_Args : EventArgs {
 120    ///<summary>Actual event payload.</summary>
 121    public bool arg { get; set; }
 122 }
 123 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Focus.Object.Focus_managerChangedEvt"/>.</summary>
 124 public class ObjectFocus_managerChangedEvt_Args : EventArgs {
 125    ///<summary>Actual event payload.</summary>
 126    public Efl.Ui.Focus.Manager arg { get; set; }
 127 }
 128 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Focus.Object.Focus_parentChangedEvt"/>.</summary>
 129 public class ObjectFocus_parentChangedEvt_Args : EventArgs {
 130    ///<summary>Actual event payload.</summary>
 131    public Efl.Ui.Focus.Object arg { get; set; }
 132 }
 133 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Focus.Object.Child_focusChangedEvt"/>.</summary>
 134 public class ObjectChild_focusChangedEvt_Args : EventArgs {
 135    ///<summary>Actual event payload.</summary>
 136    public bool arg { get; set; }
 137 }
 138 /// <summary>Functions of focusable objects.
 139 /// 1.20</summary>
 140 sealed public class ObjectConcrete :
 141
 142 Object
 143
 144 {
 145    ///<summary>Pointer to the native class description.</summary>
 146    public System.IntPtr NativeClass {
 147       get {
 148          if (((object)this).GetType() == typeof (ObjectConcrete))
 149             return Efl.Ui.Focus.ObjectNativeInherit.GetEflClassStatic();
 150          else
 151             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 152       }
 153    }
 154    private EventHandlerList eventHandlers = new EventHandlerList();
 155    private  System.IntPtr handle;
 156    ///<summary>Pointer to the native instance.</summary>
 157    public System.IntPtr NativeHandle {
 158       get { return handle; }
 159    }
 160    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
 161       efl_ui_focus_object_mixin_get();
 162    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 163    public ObjectConcrete(System.IntPtr raw)
 164    {
 165       handle = raw;
 166       register_event_proxies();
 167    }
 168    ///<summary>Destructor.</summary>
 169    ~ObjectConcrete()
 170    {
 171       Dispose(false);
 172    }
 173    ///<summary>Releases the underlying native instance.</summary>
 174    void Dispose(bool disposing)
 175    {
 176       if (handle != System.IntPtr.Zero) {
 177          Efl.Eo.Globals.efl_unref(handle);
 178          handle = System.IntPtr.Zero;
 179       }
 180    }
 181    ///<summary>Releases the underlying native instance.</summary>
 182    public void Dispose()
 183    {
 184       Dispose(true);
 185       GC.SuppressFinalize(this);
 186    }
 187    ///<summary>Casts obj into an instance of this type.</summary>
 188    public static ObjectConcrete static_cast(Efl.Object obj)
 189    {
 190       if (obj == null)
 191          throw new System.ArgumentNullException("obj");
 192       return new ObjectConcrete(obj.NativeHandle);
 193    }
 194    ///<summary>Verifies if the given object is equal to this one.</summary>
 195    public override bool Equals(object obj)
 196    {
 197       var other = obj as Efl.Object;
 198       if (other == null)
 199          return false;
 200       return this.NativeHandle == other.NativeHandle;
 201    }
 202    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 203    public override int GetHashCode()
 204    {
 205       return this.NativeHandle.ToInt32();
 206    }
 207    ///<summary>Turns the native pointer into a string representation.</summary>
 208    public override String ToString()
 209    {
 210       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 211    }
 212    private readonly object eventLock = new object();
 213    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 214    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 215       int event_count = 0;
 216       if (!event_cb_count.TryGetValue(key, out event_count))
 217          event_cb_count[key] = event_count;
 218       if (event_count == 0) {
 219          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 220          if (desc == IntPtr.Zero) {
 221             Eina.Log.Error($"Failed to get native event {key}");
 222             return false;
 223          }
 224           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 225          if (!result) {
 226             Eina.Log.Error($"Failed to add event proxy for event {key}");
 227             return false;
 228          }
 229          Eina.Error.RaiseIfUnhandledException();
 230       }
 231       event_cb_count[key]++;
 232       return true;
 233    }
 234    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 235       int event_count = 0;
 236       if (!event_cb_count.TryGetValue(key, out event_count))
 237          event_cb_count[key] = event_count;
 238       if (event_count == 1) {
 239          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 240          if (desc == IntPtr.Zero) {
 241             Eina.Log.Error($"Failed to get native event {key}");
 242             return false;
 243          }
 244          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 245          if (!result) {
 246             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 247             return false;
 248          }
 249          Eina.Error.RaiseIfUnhandledException();
 250       } else if (event_count == 0) {
 251          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 252          return false;
 253       }
 254       event_cb_count[key]--;
 255       return true;
 256    }
 257 private static object FocusChangedEvtKey = new object();
 258    /// <summary>Emitted if the focus state has changed.
 259    /// 1.20</summary>
 260    public event EventHandler<Efl.Ui.Focus.ObjectFocusChangedEvt_Args> FocusChangedEvt
 261    {
 262       add {
 263          lock (eventLock) {
 264             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_CHANGED";
 265             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_FocusChangedEvt_delegate)) {
 266                eventHandlers.AddHandler(FocusChangedEvtKey , value);
 267             } else
 268                Eina.Log.Error($"Error adding proxy for event {key}");
 269          }
 270       }
 271       remove {
 272          lock (eventLock) {
 273             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_CHANGED";
 274             if (remove_cpp_event_handler(key, this.evt_FocusChangedEvt_delegate)) {
 275                eventHandlers.RemoveHandler(FocusChangedEvtKey , value);
 276             } else
 277                Eina.Log.Error($"Error removing proxy for event {key}");
 278          }
 279       }
 280    }
 281    ///<summary>Method to raise event FocusChangedEvt.</summary>
 282    public void On_FocusChangedEvt(Efl.Ui.Focus.ObjectFocusChangedEvt_Args e)
 283    {
 284       EventHandler<Efl.Ui.Focus.ObjectFocusChangedEvt_Args> evt;
 285       lock (eventLock) {
 286       evt = (EventHandler<Efl.Ui.Focus.ObjectFocusChangedEvt_Args>)eventHandlers[FocusChangedEvtKey];
 287       }
 288       evt?.Invoke(this, e);
 289    }
 290    Efl.EventCb evt_FocusChangedEvt_delegate;
 291    private void on_FocusChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 292    {
 293       Efl.Ui.Focus.ObjectFocusChangedEvt_Args args = new Efl.Ui.Focus.ObjectFocusChangedEvt_Args();
 294       args.arg = evt.Info != IntPtr.Zero;
 295       try {
 296          On_FocusChangedEvt(args);
 297       } catch (Exception e) {
 298          Eina.Log.Error(e.ToString());
 299          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 300       }
 301    }
 302
 303 private static object Focus_managerChangedEvtKey = new object();
 304    /// <summary>Emitted when a new manager is the parent for this object.
 305    /// 1.20</summary>
 306    public event EventHandler<Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args> Focus_managerChangedEvt
 307    {
 308       add {
 309          lock (eventLock) {
 310             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED";
 311             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Focus_managerChangedEvt_delegate)) {
 312                eventHandlers.AddHandler(Focus_managerChangedEvtKey , value);
 313             } else
 314                Eina.Log.Error($"Error adding proxy for event {key}");
 315          }
 316       }
 317       remove {
 318          lock (eventLock) {
 319             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED";
 320             if (remove_cpp_event_handler(key, this.evt_Focus_managerChangedEvt_delegate)) {
 321                eventHandlers.RemoveHandler(Focus_managerChangedEvtKey , value);
 322             } else
 323                Eina.Log.Error($"Error removing proxy for event {key}");
 324          }
 325       }
 326    }
 327    ///<summary>Method to raise event Focus_managerChangedEvt.</summary>
 328    public void On_Focus_managerChangedEvt(Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args e)
 329    {
 330       EventHandler<Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args> evt;
 331       lock (eventLock) {
 332       evt = (EventHandler<Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args>)eventHandlers[Focus_managerChangedEvtKey];
 333       }
 334       evt?.Invoke(this, e);
 335    }
 336    Efl.EventCb evt_Focus_managerChangedEvt_delegate;
 337    private void on_Focus_managerChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 338    {
 339       Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args args = new Efl.Ui.Focus.ObjectFocus_managerChangedEvt_Args();
 340       args.arg = new Efl.Ui.Focus.ManagerConcrete(evt.Info);
 341       try {
 342          On_Focus_managerChangedEvt(args);
 343       } catch (Exception e) {
 344          Eina.Log.Error(e.ToString());
 345          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 346       }
 347    }
 348
 349 private static object Focus_parentChangedEvtKey = new object();
 350    /// <summary>Emitted when a new logical parent should be used.
 351    /// 1.20</summary>
 352    public event EventHandler<Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args> Focus_parentChangedEvt
 353    {
 354       add {
 355          lock (eventLock) {
 356             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_PARENT_CHANGED";
 357             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Focus_parentChangedEvt_delegate)) {
 358                eventHandlers.AddHandler(Focus_parentChangedEvtKey , value);
 359             } else
 360                Eina.Log.Error($"Error adding proxy for event {key}");
 361          }
 362       }
 363       remove {
 364          lock (eventLock) {
 365             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_PARENT_CHANGED";
 366             if (remove_cpp_event_handler(key, this.evt_Focus_parentChangedEvt_delegate)) {
 367                eventHandlers.RemoveHandler(Focus_parentChangedEvtKey , value);
 368             } else
 369                Eina.Log.Error($"Error removing proxy for event {key}");
 370          }
 371       }
 372    }
 373    ///<summary>Method to raise event Focus_parentChangedEvt.</summary>
 374    public void On_Focus_parentChangedEvt(Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args e)
 375    {
 376       EventHandler<Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args> evt;
 377       lock (eventLock) {
 378       evt = (EventHandler<Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args>)eventHandlers[Focus_parentChangedEvtKey];
 379       }
 380       evt?.Invoke(this, e);
 381    }
 382    Efl.EventCb evt_Focus_parentChangedEvt_delegate;
 383    private void on_Focus_parentChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 384    {
 385       Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args args = new Efl.Ui.Focus.ObjectFocus_parentChangedEvt_Args();
 386       args.arg = new Efl.Ui.Focus.ObjectConcrete(evt.Info);
 387       try {
 388          On_Focus_parentChangedEvt(args);
 389       } catch (Exception e) {
 390          Eina.Log.Error(e.ToString());
 391          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 392       }
 393    }
 394
 395 private static object Child_focusChangedEvtKey = new object();
 396    /// <summary>Emitted if child_focus has changed.
 397    /// 1.20</summary>
 398    public event EventHandler<Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args> Child_focusChangedEvt
 399    {
 400       add {
 401          lock (eventLock) {
 402             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_CHILD_FOCUS_CHANGED";
 403             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Child_focusChangedEvt_delegate)) {
 404                eventHandlers.AddHandler(Child_focusChangedEvtKey , value);
 405             } else
 406                Eina.Log.Error($"Error adding proxy for event {key}");
 407          }
 408       }
 409       remove {
 410          lock (eventLock) {
 411             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_CHILD_FOCUS_CHANGED";
 412             if (remove_cpp_event_handler(key, this.evt_Child_focusChangedEvt_delegate)) {
 413                eventHandlers.RemoveHandler(Child_focusChangedEvtKey , value);
 414             } else
 415                Eina.Log.Error($"Error removing proxy for event {key}");
 416          }
 417       }
 418    }
 419    ///<summary>Method to raise event Child_focusChangedEvt.</summary>
 420    public void On_Child_focusChangedEvt(Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args e)
 421    {
 422       EventHandler<Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args> evt;
 423       lock (eventLock) {
 424       evt = (EventHandler<Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args>)eventHandlers[Child_focusChangedEvtKey];
 425       }
 426       evt?.Invoke(this, e);
 427    }
 428    Efl.EventCb evt_Child_focusChangedEvt_delegate;
 429    private void on_Child_focusChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 430    {
 431       Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args args = new Efl.Ui.Focus.ObjectChild_focusChangedEvt_Args();
 432       args.arg = evt.Info != IntPtr.Zero;
 433       try {
 434          On_Child_focusChangedEvt(args);
 435       } catch (Exception e) {
 436          Eina.Log.Error(e.ToString());
 437          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 438       }
 439    }
 440
 441 private static object Focus_geometryChangedEvtKey = new object();
 442    /// <summary>Emitted if focus geometry of this object has changed.
 443    /// 1.20</summary>
 444    public event EventHandler Focus_geometryChangedEvt
 445    {
 446       add {
 447          lock (eventLock) {
 448             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_GEOMETRY_CHANGED";
 449             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Focus_geometryChangedEvt_delegate)) {
 450                eventHandlers.AddHandler(Focus_geometryChangedEvtKey , value);
 451             } else
 452                Eina.Log.Error($"Error adding proxy for event {key}");
 453          }
 454       }
 455       remove {
 456          lock (eventLock) {
 457             string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_GEOMETRY_CHANGED";
 458             if (remove_cpp_event_handler(key, this.evt_Focus_geometryChangedEvt_delegate)) {
 459                eventHandlers.RemoveHandler(Focus_geometryChangedEvtKey , value);
 460             } else
 461                Eina.Log.Error($"Error removing proxy for event {key}");
 462          }
 463       }
 464    }
 465    ///<summary>Method to raise event Focus_geometryChangedEvt.</summary>
 466    public void On_Focus_geometryChangedEvt(EventArgs e)
 467    {
 468       EventHandler evt;
 469       lock (eventLock) {
 470       evt = (EventHandler)eventHandlers[Focus_geometryChangedEvtKey];
 471       }
 472       evt?.Invoke(this, e);
 473    }
 474    Efl.EventCb evt_Focus_geometryChangedEvt_delegate;
 475    private void on_Focus_geometryChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 476    {
 477       EventArgs args = EventArgs.Empty;
 478       try {
 479          On_Focus_geometryChangedEvt(args);
 480       } catch (Exception e) {
 481          Eina.Log.Error(e.ToString());
 482          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 483       }
 484    }
 485
 486     void register_event_proxies()
 487    {
 488       evt_FocusChangedEvt_delegate = new Efl.EventCb(on_FocusChangedEvt_NativeCallback);
 489       evt_Focus_managerChangedEvt_delegate = new Efl.EventCb(on_Focus_managerChangedEvt_NativeCallback);
 490       evt_Focus_parentChangedEvt_delegate = new Efl.EventCb(on_Focus_parentChangedEvt_NativeCallback);
 491       evt_Child_focusChangedEvt_delegate = new Efl.EventCb(on_Child_focusChangedEvt_NativeCallback);
 492       evt_Focus_geometryChangedEvt_delegate = new Efl.EventCb(on_Focus_geometryChangedEvt_NativeCallback);
 493    }
 494    /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
 495    /// 1.20</summary>
 496    /// <returns>The geometry to use.
 497    /// 1.20</returns>
 498    public Eina.Rect GetFocusGeometry() {
 499        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_focus_geometry_get_ptr.Value.Delegate(this.NativeHandle);
 500       Eina.Error.RaiseIfUnhandledException();
 501       return Eina.Rect_StructConversion.ToManaged(_ret_var);
 502  }
 503    /// <summary>Returns whether the widget is currently focused or not.
 504    /// 1.20</summary>
 505    /// <returns>The focused state of the object.
 506    /// 1.20</returns>
 507    public bool GetFocus() {
 508        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_focus_get_ptr.Value.Delegate(this.NativeHandle);
 509       Eina.Error.RaiseIfUnhandledException();
 510       return _ret_var;
 511  }
 512    /// <summary>This is called by the manager and should never be called by anyone else.
 513    /// The function emits the focus state events, if focus is different to the previous state.
 514    /// 1.20</summary>
 515    /// <param name="focus">The focused state of the object.
 516    /// 1.20</param>
 517    /// <returns></returns>
 518    public  void SetFocus( bool focus) {
 519                          Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_focus_set_ptr.Value.Delegate(this.NativeHandle, focus);
 520       Eina.Error.RaiseIfUnhandledException();
 521                    }
 522    /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
 523    /// 1.20</summary>
 524    /// <returns>The manager object
 525    /// 1.20</returns>
 526    public Efl.Ui.Focus.Manager GetFocusManager() {
 527        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_focus_manager_get_ptr.Value.Delegate(this.NativeHandle);
 528       Eina.Error.RaiseIfUnhandledException();
 529       return _ret_var;
 530  }
 531    /// <summary>Describes which logical parent is used by this object.
 532    /// 1.20</summary>
 533    /// <returns>The focus parent.
 534    /// 1.20</returns>
 535    public Efl.Ui.Focus.Object GetFocusParent() {
 536        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_focus_parent_get_ptr.Value.Delegate(this.NativeHandle);
 537       Eina.Error.RaiseIfUnhandledException();
 538       return _ret_var;
 539  }
 540    /// <summary>Indicates if a child of this object has focus set to true.
 541    /// 1.20</summary>
 542    /// <returns><c>true</c> if a child has focus.
 543    /// 1.20</returns>
 544    public bool GetChildFocus() {
 545        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_child_focus_get_ptr.Value.Delegate(this.NativeHandle);
 546       Eina.Error.RaiseIfUnhandledException();
 547       return _ret_var;
 548  }
 549    /// <summary>Indicates if a child of this object has focus set to true.
 550    /// 1.20</summary>
 551    /// <param name="child_focus"><c>true</c> if a child has focus.
 552    /// 1.20</param>
 553    /// <returns></returns>
 554    public  void SetChildFocus( bool child_focus) {
 555                          Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_child_focus_set_ptr.Value.Delegate(this.NativeHandle, child_focus);
 556       Eina.Error.RaiseIfUnhandledException();
 557                    }
 558    /// <summary>Tells the object that its children will be queried soon by the focus manager. Overwrite this to update the order of the children. Deleting items in this call will result in undefined behaviour and may cause your system to crash.
 559    /// 1.20</summary>
 560    /// <returns></returns>
 561    public  void SetupOrder() {
 562        Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_setup_order_ptr.Value.Delegate(this.NativeHandle);
 563       Eina.Error.RaiseIfUnhandledException();
 564        }
 565    /// <summary>This is called when <see cref="Efl.Ui.Focus.Object.SetupOrder"/> is called, but only on the first call, additional recursive calls to <see cref="Efl.Ui.Focus.Object.SetupOrder"/> will not call this function again.
 566    /// 1.20</summary>
 567    /// <returns></returns>
 568    public  void SetupOrderNonRecursive() {
 569        Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_setup_order_non_recursive_ptr.Value.Delegate(this.NativeHandle);
 570       Eina.Error.RaiseIfUnhandledException();
 571        }
 572    /// <summary>Virtual function handling focus in/out events on the widget
 573    /// 1.20</summary>
 574    /// <returns><c>true</c> if this widget can handle focus, <c>false</c> otherwise
 575    /// 1.20</returns>
 576    public bool UpdateOnFocus() {
 577        var _ret_var = Efl.Ui.Focus.ObjectNativeInherit.efl_ui_focus_object_on_focus_update_ptr.Value.Delegate(this.NativeHandle);
 578       Eina.Error.RaiseIfUnhandledException();
 579       return _ret_var;
 580  }
 581    /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
 582 /// 1.20</summary>
 583 /// <value>The geometry to use.
 584 /// 1.20</value>
 585    public Eina.Rect FocusGeometry {
 586       get { return GetFocusGeometry(); }
 587    }
 588    /// <summary>Returns whether the widget is currently focused or not.
 589 /// 1.20</summary>
 590 /// <value>The focused state of the object.
 591 /// 1.20</value>
 592    public bool Focus {
 593       get { return GetFocus(); }
 594       set { SetFocus( value); }
 595    }
 596    /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
 597 /// 1.20</summary>
 598 /// <value>The manager object
 599 /// 1.20</value>
 600    public Efl.Ui.Focus.Manager FocusManager {
 601       get { return GetFocusManager(); }
 602    }
 603    /// <summary>Describes which logical parent is used by this object.
 604 /// 1.20</summary>
 605 /// <value>The focus parent.
 606 /// 1.20</value>
 607    public Efl.Ui.Focus.Object FocusParent {
 608       get { return GetFocusParent(); }
 609    }
 610    /// <summary>Indicates if a child of this object has focus set to true.
 611 /// 1.20</summary>
 612 /// <value><c>true</c> if a child has focus.
 613 /// 1.20</value>
 614    public bool ChildFocus {
 615       get { return GetChildFocus(); }
 616       set { SetChildFocus( value); }
 617    }
 618 }
 619 public class ObjectNativeInherit  : Efl.Eo.NativeClass{
 620    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 621    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 622    {
 623       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 624       if (efl_ui_focus_object_focus_geometry_get_static_delegate == null)
 625       efl_ui_focus_object_focus_geometry_get_static_delegate = new efl_ui_focus_object_focus_geometry_get_delegate(focus_geometry_get);
 626       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_geometry_get_static_delegate)});
 627       if (efl_ui_focus_object_focus_get_static_delegate == null)
 628       efl_ui_focus_object_focus_get_static_delegate = new efl_ui_focus_object_focus_get_delegate(focus_get);
 629       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_get_static_delegate)});
 630       if (efl_ui_focus_object_focus_set_static_delegate == null)
 631       efl_ui_focus_object_focus_set_static_delegate = new efl_ui_focus_object_focus_set_delegate(focus_set);
 632       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_set_static_delegate)});
 633       if (efl_ui_focus_object_focus_manager_get_static_delegate == null)
 634       efl_ui_focus_object_focus_manager_get_static_delegate = new efl_ui_focus_object_focus_manager_get_delegate(focus_manager_get);
 635       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_manager_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_manager_get_static_delegate)});
 636       if (efl_ui_focus_object_focus_parent_get_static_delegate == null)
 637       efl_ui_focus_object_focus_parent_get_static_delegate = new efl_ui_focus_object_focus_parent_get_delegate(focus_parent_get);
 638       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_parent_get_static_delegate)});
 639       if (efl_ui_focus_object_child_focus_get_static_delegate == null)
 640       efl_ui_focus_object_child_focus_get_static_delegate = new efl_ui_focus_object_child_focus_get_delegate(child_focus_get);
 641       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_child_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_child_focus_get_static_delegate)});
 642       if (efl_ui_focus_object_child_focus_set_static_delegate == null)
 643       efl_ui_focus_object_child_focus_set_static_delegate = new efl_ui_focus_object_child_focus_set_delegate(child_focus_set);
 644       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_child_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_child_focus_set_static_delegate)});
 645       if (efl_ui_focus_object_setup_order_static_delegate == null)
 646       efl_ui_focus_object_setup_order_static_delegate = new efl_ui_focus_object_setup_order_delegate(setup_order);
 647       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_setup_order"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_setup_order_static_delegate)});
 648       if (efl_ui_focus_object_setup_order_non_recursive_static_delegate == null)
 649       efl_ui_focus_object_setup_order_non_recursive_static_delegate = new efl_ui_focus_object_setup_order_non_recursive_delegate(setup_order_non_recursive);
 650       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_setup_order_non_recursive"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_setup_order_non_recursive_static_delegate)});
 651       if (efl_ui_focus_object_on_focus_update_static_delegate == null)
 652       efl_ui_focus_object_on_focus_update_static_delegate = new efl_ui_focus_object_on_focus_update_delegate(on_focus_update);
 653       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_on_focus_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_on_focus_update_static_delegate)});
 654       return descs;
 655    }
 656    public override IntPtr GetEflClass()
 657    {
 658       return Efl.Ui.Focus.ObjectConcrete.efl_ui_focus_object_mixin_get();
 659    }
 660    public static  IntPtr GetEflClassStatic()
 661    {
 662       return Efl.Ui.Focus.ObjectConcrete.efl_ui_focus_object_mixin_get();
 663    }
 664
 665
 666     private delegate Eina.Rect_StructInternal efl_ui_focus_object_focus_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
 667
 668
 669     public delegate Eina.Rect_StructInternal efl_ui_focus_object_focus_geometry_get_api_delegate(System.IntPtr obj);
 670     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_geometry_get_api_delegate> efl_ui_focus_object_focus_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_geometry_get_api_delegate>(_Module, "efl_ui_focus_object_focus_geometry_get");
 671     private static Eina.Rect_StructInternal focus_geometry_get(System.IntPtr obj, System.IntPtr pd)
 672    {
 673       Eina.Log.Debug("function efl_ui_focus_object_focus_geometry_get was called");
 674       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 675       if(wrapper != null) {
 676                   Eina.Rect _ret_var = default(Eina.Rect);
 677          try {
 678             _ret_var = ((ObjectConcrete)wrapper).GetFocusGeometry();
 679          } catch (Exception e) {
 680             Eina.Log.Warning($"Callback error: {e.ToString()}");
 681             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 682          }
 683       return Eina.Rect_StructConversion.ToInternal(_ret_var);
 684       } else {
 685          return efl_ui_focus_object_focus_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 686       }
 687    }
 688    private static efl_ui_focus_object_focus_geometry_get_delegate efl_ui_focus_object_focus_geometry_get_static_delegate;
 689
 690
 691     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
 692
 693
 694     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_focus_get_api_delegate(System.IntPtr obj);
 695     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_get_api_delegate> efl_ui_focus_object_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_get_api_delegate>(_Module, "efl_ui_focus_object_focus_get");
 696     private static bool focus_get(System.IntPtr obj, System.IntPtr pd)
 697    {
 698       Eina.Log.Debug("function efl_ui_focus_object_focus_get was called");
 699       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 700       if(wrapper != null) {
 701                   bool _ret_var = default(bool);
 702          try {
 703             _ret_var = ((ObjectConcrete)wrapper).GetFocus();
 704          } catch (Exception e) {
 705             Eina.Log.Warning($"Callback error: {e.ToString()}");
 706             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 707          }
 708       return _ret_var;
 709       } else {
 710          return efl_ui_focus_object_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 711       }
 712    }
 713    private static efl_ui_focus_object_focus_get_delegate efl_ui_focus_object_focus_get_static_delegate;
 714
 715
 716     private delegate  void efl_ui_focus_object_focus_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool focus);
 717
 718
 719     public delegate  void efl_ui_focus_object_focus_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool focus);
 720     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_set_api_delegate> efl_ui_focus_object_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_set_api_delegate>(_Module, "efl_ui_focus_object_focus_set");
 721     private static  void focus_set(System.IntPtr obj, System.IntPtr pd,  bool focus)
 722    {
 723       Eina.Log.Debug("function efl_ui_focus_object_focus_set was called");
 724       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 725       if(wrapper != null) {
 726
 727          try {
 728             ((ObjectConcrete)wrapper).SetFocus( focus);
 729          } catch (Exception e) {
 730             Eina.Log.Warning($"Callback error: {e.ToString()}");
 731             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 732          }
 733                         } else {
 734          efl_ui_focus_object_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  focus);
 735       }
 736    }
 737    private static efl_ui_focus_object_focus_set_delegate efl_ui_focus_object_focus_set_static_delegate;
 738
 739
 740    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Focus.Manager efl_ui_focus_object_focus_manager_get_delegate(System.IntPtr obj, System.IntPtr pd);
 741
 742
 743    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Focus.Manager efl_ui_focus_object_focus_manager_get_api_delegate(System.IntPtr obj);
 744     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_manager_get_api_delegate> efl_ui_focus_object_focus_manager_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_manager_get_api_delegate>(_Module, "efl_ui_focus_object_focus_manager_get");
 745     private static Efl.Ui.Focus.Manager focus_manager_get(System.IntPtr obj, System.IntPtr pd)
 746    {
 747       Eina.Log.Debug("function efl_ui_focus_object_focus_manager_get was called");
 748       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 749       if(wrapper != null) {
 750                   Efl.Ui.Focus.Manager _ret_var = default(Efl.Ui.Focus.Manager);
 751          try {
 752             _ret_var = ((ObjectConcrete)wrapper).GetFocusManager();
 753          } catch (Exception e) {
 754             Eina.Log.Warning($"Callback error: {e.ToString()}");
 755             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 756          }
 757       return _ret_var;
 758       } else {
 759          return efl_ui_focus_object_focus_manager_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 760       }
 761    }
 762    private static efl_ui_focus_object_focus_manager_get_delegate efl_ui_focus_object_focus_manager_get_static_delegate;
 763
 764
 765    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Focus.Object efl_ui_focus_object_focus_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
 766
 767
 768    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Focus.Object efl_ui_focus_object_focus_parent_get_api_delegate(System.IntPtr obj);
 769     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_parent_get_api_delegate> efl_ui_focus_object_focus_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_parent_get_api_delegate>(_Module, "efl_ui_focus_object_focus_parent_get");
 770     private static Efl.Ui.Focus.Object focus_parent_get(System.IntPtr obj, System.IntPtr pd)
 771    {
 772       Eina.Log.Debug("function efl_ui_focus_object_focus_parent_get was called");
 773       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 774       if(wrapper != null) {
 775                   Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
 776          try {
 777             _ret_var = ((ObjectConcrete)wrapper).GetFocusParent();
 778          } catch (Exception e) {
 779             Eina.Log.Warning($"Callback error: {e.ToString()}");
 780             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 781          }
 782       return _ret_var;
 783       } else {
 784          return efl_ui_focus_object_focus_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 785       }
 786    }
 787    private static efl_ui_focus_object_focus_parent_get_delegate efl_ui_focus_object_focus_parent_get_static_delegate;
 788
 789
 790     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_child_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
 791
 792
 793     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_child_focus_get_api_delegate(System.IntPtr obj);
 794     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_get_api_delegate> efl_ui_focus_object_child_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_get_api_delegate>(_Module, "efl_ui_focus_object_child_focus_get");
 795     private static bool child_focus_get(System.IntPtr obj, System.IntPtr pd)
 796    {
 797       Eina.Log.Debug("function efl_ui_focus_object_child_focus_get was called");
 798       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 799       if(wrapper != null) {
 800                   bool _ret_var = default(bool);
 801          try {
 802             _ret_var = ((ObjectConcrete)wrapper).GetChildFocus();
 803          } catch (Exception e) {
 804             Eina.Log.Warning($"Callback error: {e.ToString()}");
 805             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 806          }
 807       return _ret_var;
 808       } else {
 809          return efl_ui_focus_object_child_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 810       }
 811    }
 812    private static efl_ui_focus_object_child_focus_get_delegate efl_ui_focus_object_child_focus_get_static_delegate;
 813
 814
 815     private delegate  void efl_ui_focus_object_child_focus_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool child_focus);
 816
 817
 818     public delegate  void efl_ui_focus_object_child_focus_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool child_focus);
 819     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_set_api_delegate> efl_ui_focus_object_child_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_set_api_delegate>(_Module, "efl_ui_focus_object_child_focus_set");
 820     private static  void child_focus_set(System.IntPtr obj, System.IntPtr pd,  bool child_focus)
 821    {
 822       Eina.Log.Debug("function efl_ui_focus_object_child_focus_set was called");
 823       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 824       if(wrapper != null) {
 825
 826          try {
 827             ((ObjectConcrete)wrapper).SetChildFocus( child_focus);
 828          } catch (Exception e) {
 829             Eina.Log.Warning($"Callback error: {e.ToString()}");
 830             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 831          }
 832                         } else {
 833          efl_ui_focus_object_child_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child_focus);
 834       }
 835    }
 836    private static efl_ui_focus_object_child_focus_set_delegate efl_ui_focus_object_child_focus_set_static_delegate;
 837
 838
 839     private delegate  void efl_ui_focus_object_setup_order_delegate(System.IntPtr obj, System.IntPtr pd);
 840
 841
 842     public delegate  void efl_ui_focus_object_setup_order_api_delegate(System.IntPtr obj);
 843     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_api_delegate> efl_ui_focus_object_setup_order_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_api_delegate>(_Module, "efl_ui_focus_object_setup_order");
 844     private static  void setup_order(System.IntPtr obj, System.IntPtr pd)
 845    {
 846       Eina.Log.Debug("function efl_ui_focus_object_setup_order was called");
 847       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 848       if(wrapper != null) {
 849
 850          try {
 851             ((ObjectConcrete)wrapper).SetupOrder();
 852          } catch (Exception e) {
 853             Eina.Log.Warning($"Callback error: {e.ToString()}");
 854             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 855          }
 856             } else {
 857          efl_ui_focus_object_setup_order_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 858       }
 859    }
 860    private static efl_ui_focus_object_setup_order_delegate efl_ui_focus_object_setup_order_static_delegate;
 861
 862
 863     private delegate  void efl_ui_focus_object_setup_order_non_recursive_delegate(System.IntPtr obj, System.IntPtr pd);
 864
 865
 866     public delegate  void efl_ui_focus_object_setup_order_non_recursive_api_delegate(System.IntPtr obj);
 867     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_non_recursive_api_delegate> efl_ui_focus_object_setup_order_non_recursive_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_non_recursive_api_delegate>(_Module, "efl_ui_focus_object_setup_order_non_recursive");
 868     private static  void setup_order_non_recursive(System.IntPtr obj, System.IntPtr pd)
 869    {
 870       Eina.Log.Debug("function efl_ui_focus_object_setup_order_non_recursive was called");
 871       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 872       if(wrapper != null) {
 873
 874          try {
 875             ((ObjectConcrete)wrapper).SetupOrderNonRecursive();
 876          } catch (Exception e) {
 877             Eina.Log.Warning($"Callback error: {e.ToString()}");
 878             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 879          }
 880             } else {
 881          efl_ui_focus_object_setup_order_non_recursive_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 882       }
 883    }
 884    private static efl_ui_focus_object_setup_order_non_recursive_delegate efl_ui_focus_object_setup_order_non_recursive_static_delegate;
 885
 886
 887     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_on_focus_update_delegate(System.IntPtr obj, System.IntPtr pd);
 888
 889
 890     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_on_focus_update_api_delegate(System.IntPtr obj);
 891     public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_on_focus_update_api_delegate> efl_ui_focus_object_on_focus_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_on_focus_update_api_delegate>(_Module, "efl_ui_focus_object_on_focus_update");
 892     private static bool on_focus_update(System.IntPtr obj, System.IntPtr pd)
 893    {
 894       Eina.Log.Debug("function efl_ui_focus_object_on_focus_update was called");
 895       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 896       if(wrapper != null) {
 897                   bool _ret_var = default(bool);
 898          try {
 899             _ret_var = ((ObjectConcrete)wrapper).UpdateOnFocus();
 900          } catch (Exception e) {
 901             Eina.Log.Warning($"Callback error: {e.ToString()}");
 902             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 903          }
 904       return _ret_var;
 905       } else {
 906          return efl_ui_focus_object_on_focus_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 907       }
 908    }
 909    private static efl_ui_focus_object_on_focus_update_delegate efl_ui_focus_object_on_focus_update_static_delegate;
 910 }
 911 } } }