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