internals/src/EflSharp/EflSharp/efl_ui_focus_manager_calc.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>Calculates the directions of Efl.Ui.Focus.Direction
   9 /// Each registered item will get an other registered object in each direction. You can get items for the currently focused item if you call request move.
  10 /// 1.20</summary>
  11 [ManagerCalcNativeInherit]
  12 public class ManagerCalc : Efl.Object, Efl.Eo.IWrapper,Efl.Ui.Focus.Manager
  13 {
  14    public new static System.IntPtr klass = System.IntPtr.Zero;
  15    public new static Efl.Ui.Focus.ManagerCalcNativeInherit nativeInherit = new Efl.Ui.Focus.ManagerCalcNativeInherit();
  16    ///<summary>Pointer to the native class description.</summary>
  17    public override System.IntPtr NativeClass {
  18       get {
  19          if (((object)this).GetType() == typeof (ManagerCalc))
  20             return Efl.Ui.Focus.ManagerCalcNativeInherit.GetEflClassStatic();
  21          else
  22             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  23       }
  24    }
  25    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  26       efl_ui_focus_manager_calc_class_get();
  27    ///<summary>Creates a new instance.</summary>
  28    ///<param name="parent">Parent instance.</param>
  29    public ManagerCalc(Efl.Object parent= null
  30          ) :
  31       base(efl_ui_focus_manager_calc_class_get(), typeof(ManagerCalc), parent)
  32    {
  33       FinishInstantiation();
  34    }
  35    ///<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>
  36    public ManagerCalc(System.IntPtr raw) : base(raw)
  37    {
  38             register_event_proxies();
  39    }
  40    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  41    protected ManagerCalc(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  42    ///<summary>Casts obj into an instance of this type.</summary>
  43    public new static ManagerCalc static_cast(Efl.Object obj)
  44    {
  45       if (obj == null)
  46          throw new System.ArgumentNullException("obj");
  47       return new ManagerCalc(obj.NativeHandle);
  48    }
  49    ///<summary>Verifies if the given object is equal to this one.</summary>
  50    public override bool Equals(object obj)
  51    {
  52       var other = obj as Efl.Object;
  53       if (other == null)
  54          return false;
  55       return this.NativeHandle == other.NativeHandle;
  56    }
  57    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  58    public override int GetHashCode()
  59    {
  60       return this.NativeHandle.ToInt32();
  61    }
  62    ///<summary>Turns the native pointer into a string representation.</summary>
  63    public override String ToString()
  64    {
  65       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  66    }
  67 private static object RedirectChangedEvtKey = new object();
  68    /// <summary>Redirect object has changed, the old manager is passed as an event argument.
  69    /// 1.20</summary>
  70    public event EventHandler<Efl.Ui.Focus.ManagerRedirectChangedEvt_Args> RedirectChangedEvt
  71    {
  72       add {
  73          lock (eventLock) {
  74             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
  75             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_RedirectChangedEvt_delegate)) {
  76                eventHandlers.AddHandler(RedirectChangedEvtKey , value);
  77             } else
  78                Eina.Log.Error($"Error adding proxy for event {key}");
  79          }
  80       }
  81       remove {
  82          lock (eventLock) {
  83             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
  84             if (remove_cpp_event_handler(key, this.evt_RedirectChangedEvt_delegate)) {
  85                eventHandlers.RemoveHandler(RedirectChangedEvtKey , value);
  86             } else
  87                Eina.Log.Error($"Error removing proxy for event {key}");
  88          }
  89       }
  90    }
  91    ///<summary>Method to raise event RedirectChangedEvt.</summary>
  92    public void On_RedirectChangedEvt(Efl.Ui.Focus.ManagerRedirectChangedEvt_Args e)
  93    {
  94       EventHandler<Efl.Ui.Focus.ManagerRedirectChangedEvt_Args> evt;
  95       lock (eventLock) {
  96       evt = (EventHandler<Efl.Ui.Focus.ManagerRedirectChangedEvt_Args>)eventHandlers[RedirectChangedEvtKey];
  97       }
  98       evt?.Invoke(this, e);
  99    }
 100    Efl.EventCb evt_RedirectChangedEvt_delegate;
 101    private void on_RedirectChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 102    {
 103       Efl.Ui.Focus.ManagerRedirectChangedEvt_Args args = new Efl.Ui.Focus.ManagerRedirectChangedEvt_Args();
 104       args.arg = new Efl.Ui.Focus.ManagerConcrete(evt.Info);
 105       try {
 106          On_RedirectChangedEvt(args);
 107       } catch (Exception e) {
 108          Eina.Log.Error(e.ToString());
 109          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 110       }
 111    }
 112
 113 private static object FlushPreEvtKey = new object();
 114    /// <summary>After this event, the manager object will calculate relations in the graph. Can be used to add / remove children in a lazy fashion.
 115    /// 1.20</summary>
 116    public event EventHandler FlushPreEvt
 117    {
 118       add {
 119          lock (eventLock) {
 120             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 121             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_FlushPreEvt_delegate)) {
 122                eventHandlers.AddHandler(FlushPreEvtKey , value);
 123             } else
 124                Eina.Log.Error($"Error adding proxy for event {key}");
 125          }
 126       }
 127       remove {
 128          lock (eventLock) {
 129             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 130             if (remove_cpp_event_handler(key, this.evt_FlushPreEvt_delegate)) {
 131                eventHandlers.RemoveHandler(FlushPreEvtKey , value);
 132             } else
 133                Eina.Log.Error($"Error removing proxy for event {key}");
 134          }
 135       }
 136    }
 137    ///<summary>Method to raise event FlushPreEvt.</summary>
 138    public void On_FlushPreEvt(EventArgs e)
 139    {
 140       EventHandler evt;
 141       lock (eventLock) {
 142       evt = (EventHandler)eventHandlers[FlushPreEvtKey];
 143       }
 144       evt?.Invoke(this, e);
 145    }
 146    Efl.EventCb evt_FlushPreEvt_delegate;
 147    private void on_FlushPreEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 148    {
 149       EventArgs args = EventArgs.Empty;
 150       try {
 151          On_FlushPreEvt(args);
 152       } catch (Exception e) {
 153          Eina.Log.Error(e.ToString());
 154          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 155       }
 156    }
 157
 158 private static object CoordsDirtyEvtKey = new object();
 159    /// <summary>Cached relationship calculation results have been invalidated.
 160    /// 1.20</summary>
 161    public event EventHandler CoordsDirtyEvt
 162    {
 163       add {
 164          lock (eventLock) {
 165             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 166             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_CoordsDirtyEvt_delegate)) {
 167                eventHandlers.AddHandler(CoordsDirtyEvtKey , value);
 168             } else
 169                Eina.Log.Error($"Error adding proxy for event {key}");
 170          }
 171       }
 172       remove {
 173          lock (eventLock) {
 174             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 175             if (remove_cpp_event_handler(key, this.evt_CoordsDirtyEvt_delegate)) {
 176                eventHandlers.RemoveHandler(CoordsDirtyEvtKey , value);
 177             } else
 178                Eina.Log.Error($"Error removing proxy for event {key}");
 179          }
 180       }
 181    }
 182    ///<summary>Method to raise event CoordsDirtyEvt.</summary>
 183    public void On_CoordsDirtyEvt(EventArgs e)
 184    {
 185       EventHandler evt;
 186       lock (eventLock) {
 187       evt = (EventHandler)eventHandlers[CoordsDirtyEvtKey];
 188       }
 189       evt?.Invoke(this, e);
 190    }
 191    Efl.EventCb evt_CoordsDirtyEvt_delegate;
 192    private void on_CoordsDirtyEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 193    {
 194       EventArgs args = EventArgs.Empty;
 195       try {
 196          On_CoordsDirtyEvt(args);
 197       } catch (Exception e) {
 198          Eina.Log.Error(e.ToString());
 199          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 200       }
 201    }
 202
 203 private static object Manager_focusChangedEvtKey = new object();
 204    /// <summary>The manager_focus property has changed. The previously focused object is passed as an event argument.
 205    /// 1.20</summary>
 206    public event EventHandler<Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args> Manager_focusChangedEvt
 207    {
 208       add {
 209          lock (eventLock) {
 210             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 211             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Manager_focusChangedEvt_delegate)) {
 212                eventHandlers.AddHandler(Manager_focusChangedEvtKey , value);
 213             } else
 214                Eina.Log.Error($"Error adding proxy for event {key}");
 215          }
 216       }
 217       remove {
 218          lock (eventLock) {
 219             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 220             if (remove_cpp_event_handler(key, this.evt_Manager_focusChangedEvt_delegate)) {
 221                eventHandlers.RemoveHandler(Manager_focusChangedEvtKey , value);
 222             } else
 223                Eina.Log.Error($"Error removing proxy for event {key}");
 224          }
 225       }
 226    }
 227    ///<summary>Method to raise event Manager_focusChangedEvt.</summary>
 228    public void On_Manager_focusChangedEvt(Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args e)
 229    {
 230       EventHandler<Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args> evt;
 231       lock (eventLock) {
 232       evt = (EventHandler<Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args>)eventHandlers[Manager_focusChangedEvtKey];
 233       }
 234       evt?.Invoke(this, e);
 235    }
 236    Efl.EventCb evt_Manager_focusChangedEvt_delegate;
 237    private void on_Manager_focusChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 238    {
 239       Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args args = new Efl.Ui.Focus.ManagerManager_focusChangedEvt_Args();
 240       args.arg = new Efl.Ui.Focus.ObjectConcrete(evt.Info);
 241       try {
 242          On_Manager_focusChangedEvt(args);
 243       } catch (Exception e) {
 244          Eina.Log.Error(e.ToString());
 245          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 246       }
 247    }
 248
 249 private static object Dirty_logic_freezeChangedEvtKey = new object();
 250    /// <summary>Called when this focus manager is frozen or thawed, even_info beeing <c>true</c> indicates that it is now frozen, <c>false</c> indicates that it is thawed.
 251    /// 1.20</summary>
 252    public event EventHandler<Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args> Dirty_logic_freezeChangedEvt
 253    {
 254       add {
 255          lock (eventLock) {
 256             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 257             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_Dirty_logic_freezeChangedEvt_delegate)) {
 258                eventHandlers.AddHandler(Dirty_logic_freezeChangedEvtKey , value);
 259             } else
 260                Eina.Log.Error($"Error adding proxy for event {key}");
 261          }
 262       }
 263       remove {
 264          lock (eventLock) {
 265             string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 266             if (remove_cpp_event_handler(key, this.evt_Dirty_logic_freezeChangedEvt_delegate)) {
 267                eventHandlers.RemoveHandler(Dirty_logic_freezeChangedEvtKey , value);
 268             } else
 269                Eina.Log.Error($"Error removing proxy for event {key}");
 270          }
 271       }
 272    }
 273    ///<summary>Method to raise event Dirty_logic_freezeChangedEvt.</summary>
 274    public void On_Dirty_logic_freezeChangedEvt(Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args e)
 275    {
 276       EventHandler<Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args> evt;
 277       lock (eventLock) {
 278       evt = (EventHandler<Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args>)eventHandlers[Dirty_logic_freezeChangedEvtKey];
 279       }
 280       evt?.Invoke(this, e);
 281    }
 282    Efl.EventCb evt_Dirty_logic_freezeChangedEvt_delegate;
 283    private void on_Dirty_logic_freezeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 284    {
 285       Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args args = new Efl.Ui.Focus.ManagerDirty_logic_freezeChangedEvt_Args();
 286       args.arg = evt.Info != IntPtr.Zero;
 287       try {
 288          On_Dirty_logic_freezeChangedEvt(args);
 289       } catch (Exception e) {
 290          Eina.Log.Error(e.ToString());
 291          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 292       }
 293    }
 294
 295    protected override void register_event_proxies()
 296    {
 297       base.register_event_proxies();
 298       evt_RedirectChangedEvt_delegate = new Efl.EventCb(on_RedirectChangedEvt_NativeCallback);
 299       evt_FlushPreEvt_delegate = new Efl.EventCb(on_FlushPreEvt_NativeCallback);
 300       evt_CoordsDirtyEvt_delegate = new Efl.EventCb(on_CoordsDirtyEvt_NativeCallback);
 301       evt_Manager_focusChangedEvt_delegate = new Efl.EventCb(on_Manager_focusChangedEvt_NativeCallback);
 302       evt_Dirty_logic_freezeChangedEvt_delegate = new Efl.EventCb(on_Dirty_logic_freezeChangedEvt_NativeCallback);
 303    }
 304    /// <summary>Register a new item in the graph.
 305    /// <c>parent</c> can not be <c>null</c>, it will be used as the parent in the logical tree. <c>redirect</c> will be set as redirect property on that manager, once <c>child</c> gets focused.
 306    /// 1.20</summary>
 307    /// <param name="child">The object to register
 308    /// 1.20</param>
 309    /// <param name="parent">The parent to use in the logical tree
 310    /// 1.20</param>
 311    /// <param name="redirect">The redirect manager to set once this child is focused can be NULL for no redirect
 312    /// 1.20</param>
 313    /// <returns><c>true</c> if successful, <c>false</c> otherwise
 314    /// 1.20</returns>
 315    virtual public bool Register( Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent,  Efl.Ui.Focus.Manager redirect) {
 316                                                              var _ret_var = Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_register_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  parent,  redirect);
 317       Eina.Error.RaiseIfUnhandledException();
 318                                           return _ret_var;
 319  }
 320    /// <summary>Register a new item only for the logical parent.
 321    /// The item can never get focus, it just helps to build a tree out of the items that are.
 322    /// 1.20</summary>
 323    /// <param name="child">The object to register
 324    /// 1.20</param>
 325    /// <param name="parent">The parent to use in the logical tree
 326    /// 1.20</param>
 327    /// <param name="redirect">The redirect manager to set once this child is focused can be <c>null</c> for no redirect
 328    /// 1.20</param>
 329    /// <returns><c>true</c> if successful, <c>false</c> otherwise
 330    /// 1.20</returns>
 331    virtual public bool RegisterLogical( Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent,  Efl.Ui.Focus.Manager redirect) {
 332                                                              var _ret_var = Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_register_logical_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  parent,  redirect);
 333       Eina.Error.RaiseIfUnhandledException();
 334                                           return _ret_var;
 335  }
 336    /// <summary>Set a new redirect object for the given child.
 337    /// Once <c>child</c> is focused the redirect manager will be set in the redirect property. Set redirect to <c>null</c> if nothing should happen.
 338    /// 1.20</summary>
 339    /// <param name="child">The child to update
 340    /// 1.20</param>
 341    /// <param name="redirect">Once <c>child</c> is focused this element will be set as redirect
 342    /// 1.20</param>
 343    /// <returns><c>true</c> if successful, <c>false</c> otherwise
 344    /// 1.20</returns>
 345    virtual public bool UpdateRedirect( Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Manager redirect) {
 346                                            var _ret_var = Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_update_redirect_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  redirect);
 347       Eina.Error.RaiseIfUnhandledException();
 348                               return _ret_var;
 349  }
 350    /// <summary>Set a new logical parent for the given child.
 351    /// 1.20</summary>
 352    /// <param name="child">The child to update
 353    /// 1.20</param>
 354    /// <param name="parent">The parent which now will be the logical parent of child
 355    /// 1.20</param>
 356    /// <returns><c>true</c> if successful, <c>false</c> otherwise
 357    /// 1.20</returns>
 358    virtual public bool UpdateParent( Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent) {
 359                                            var _ret_var = Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_update_parent_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  parent);
 360       Eina.Error.RaiseIfUnhandledException();
 361                               return _ret_var;
 362  }
 363    /// <summary>Give the list of children a different order.
 364    /// 1.20</summary>
 365    /// <param name="parent">the parent to update
 366    /// 1.20</param>
 367    /// <param name="children">the list with the new order
 368    /// 1.20</param>
 369    /// <returns><c>true</c> if successful, <c>false</c> otherwise
 370    /// 1.20</returns>
 371    virtual public bool UpdateChildren( Efl.Ui.Focus.Object parent,  Eina.List<Efl.Ui.Focus.Object> children) {
 372              var _in_children = children.Handle;
 373 children.Own = false;
 374                               var _ret_var = Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_update_children_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), parent,  _in_children);
 375       Eina.Error.RaiseIfUnhandledException();
 376                               return _ret_var;
 377  }
 378    /// <summary>Give the given order to the parent&apos;s child.
 379    /// Children from the list which are not true children are ignored.
 380    /// 1.20</summary>
 381    /// <param name="parent">the parent to update
 382    /// 1.20</param>
 383    /// <param name="children">the order of items
 384    /// 1.20</param>
 385    /// <returns></returns>
 386    virtual public  void UpdateOrder( Efl.Ui.Focus.Object parent,  Eina.List<Efl.Ui.Focus.Object> children) {
 387              var _in_children = children.Handle;
 388 children.Own = false;
 389                               Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_update_order_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), parent,  _in_children);
 390       Eina.Error.RaiseIfUnhandledException();
 391                                }
 392    /// <summary>Unregister the given item from the focus graph.
 393    /// 1.20</summary>
 394    /// <param name="child">The child to unregister.
 395    /// 1.20</param>
 396    /// <returns></returns>
 397    virtual public  void Unregister( Efl.Ui.Focus.Object child) {
 398                          Efl.Ui.Focus.ManagerCalcNativeInherit.efl_ui_focus_manager_calc_unregister_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child);
 399       Eina.Error.RaiseIfUnhandledException();
 400                    }
 401    /// <summary>The element which is currently focused by this manager
 402    /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
 403    /// 1.20</summary>
 404    /// <returns>Currently focused element.
 405    /// 1.20</returns>
 406    virtual public Efl.Ui.Focus.Object GetManagerFocus() {
 407        var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_focus_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 408       Eina.Error.RaiseIfUnhandledException();
 409       return _ret_var;
 410  }
 411    /// <summary>The element which is currently focused by this manager
 412    /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
 413    /// 1.20</summary>
 414    /// <param name="focus">Currently focused element.
 415    /// 1.20</param>
 416    /// <returns></returns>
 417    virtual public  void SetManagerFocus( Efl.Ui.Focus.Object focus) {
 418                          Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_focus_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), focus);
 419       Eina.Error.RaiseIfUnhandledException();
 420                    }
 421    /// <summary>Add another manager to serve the move requests.
 422    /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
 423    /// 1.20</summary>
 424    /// <returns>The redirect manager.
 425    /// 1.20</returns>
 426    virtual public Efl.Ui.Focus.Manager GetRedirect() {
 427        var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_redirect_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 428       Eina.Error.RaiseIfUnhandledException();
 429       return _ret_var;
 430  }
 431    /// <summary>Add another manager to serve the move requests.
 432    /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
 433    /// 1.20</summary>
 434    /// <param name="redirect">The redirect manager.
 435    /// 1.20</param>
 436    /// <returns></returns>
 437    virtual public  void SetRedirect( Efl.Ui.Focus.Manager redirect) {
 438                          Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_redirect_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), redirect);
 439       Eina.Error.RaiseIfUnhandledException();
 440                    }
 441    /// <summary>The list of elements which are at the border of the graph.
 442    /// This means one of the relations right,left or down,up are not set. This call flushes all changes. See <see cref="Efl.Ui.Focus.Manager.Move"/>
 443    /// 1.20</summary>
 444    /// <returns>An iterator over the border objects.
 445    /// 1.20</returns>
 446    virtual public Eina.Iterator<Efl.Ui.Focus.Object> GetBorderElements() {
 447        var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 448       Eina.Error.RaiseIfUnhandledException();
 449       return new Eina.Iterator<Efl.Ui.Focus.Object>(_ret_var, false, false);
 450  }
 451    /// <summary>Get all elements that are at the border of the viewport
 452    /// Every element returned by this is located inside the viewport rectangle, but has a right, left, down or up neighbor outside the viewport.
 453    /// 1.20</summary>
 454    /// <param name="viewport">The rectangle defining the viewport.
 455    /// 1.20</param>
 456    /// <returns>The list of border objects.
 457    /// 1.20</returns>
 458    virtual public Eina.Iterator<Efl.Ui.Focus.Object> GetViewportElements( Eina.Rect viewport) {
 459        var _in_viewport = Eina.Rect_StructConversion.ToInternal(viewport);
 460                   var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_viewport);
 461       Eina.Error.RaiseIfUnhandledException();
 462                   return new Eina.Iterator<Efl.Ui.Focus.Object>(_ret_var, false, false);
 463  }
 464    /// <summary>Root node for all logical subtrees.
 465    /// This property can only be set once.
 466    /// 1.20</summary>
 467    /// <returns>Will be registered into this manager object.
 468    /// 1.20</returns>
 469    virtual public Efl.Ui.Focus.Object GetRoot() {
 470        var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_root_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 471       Eina.Error.RaiseIfUnhandledException();
 472       return _ret_var;
 473  }
 474    /// <summary>Root node for all logical subtrees.
 475    /// This property can only be set once.
 476    /// 1.20</summary>
 477    /// <param name="root">Will be registered into this manager object.
 478    /// 1.20</param>
 479    /// <returns>If <c>true</c>, this is the root node
 480    /// 1.20</returns>
 481    virtual public bool SetRoot( Efl.Ui.Focus.Object root) {
 482                          var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_root_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), root);
 483       Eina.Error.RaiseIfUnhandledException();
 484                   return _ret_var;
 485  }
 486    /// <summary>Move the focus in the given direction.
 487    /// This call flushes all changes. This means all changes between the last flush and now are computed.
 488    /// 1.20</summary>
 489    /// <param name="direction">The direction to move to.
 490    /// 1.20</param>
 491    /// <returns>The element which is now focused.
 492    /// 1.20</returns>
 493    virtual public Efl.Ui.Focus.Object Move( Efl.Ui.Focus.Direction direction) {
 494                          var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), direction);
 495       Eina.Error.RaiseIfUnhandledException();
 496                   return _ret_var;
 497  }
 498    /// <summary>Return the object in the <c>direction</c> from <c>child</c>.
 499    /// 1.20</summary>
 500    /// <param name="direction">Direction to move focus.
 501    /// 1.20</param>
 502    /// <param name="child">The child to move from. Pass <c>null</c> to indicate the currently focused child.
 503    /// 1.20</param>
 504    /// <param name="logical">Wether you want to have a logical node as result or a non-logical. Note, in a <see cref="Efl.Ui.Focus.Manager.Move"/> call no logical node will get focus.
 505    /// 1.20</param>
 506    /// <returns>Object that would receive focus if moved in the given direction.
 507    /// 1.20</returns>
 508    virtual public Efl.Ui.Focus.Object MoveRequest( Efl.Ui.Focus.Direction direction,  Efl.Ui.Focus.Object child,  bool logical) {
 509                                                              var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_request_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), direction,  child,  logical);
 510       Eina.Error.RaiseIfUnhandledException();
 511                                           return _ret_var;
 512  }
 513    /// <summary>Return the widget in the direction next.
 514    /// The returned widget is a child of <c>root</c>. It&apos;s guaranteed that child will not be prepared once again, so you can call this function inside a <see cref="Efl.Ui.Focus.Object.SetupOrder"/> call.
 515    /// 1.20</summary>
 516    /// <param name="root">Parent for returned child.
 517    /// 1.20</param>
 518    /// <returns>Child of passed parameter.
 519    /// 1.20</returns>
 520    virtual public Efl.Ui.Focus.Object RequestSubchild( Efl.Ui.Focus.Object root) {
 521                          var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_request_subchild_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), root);
 522       Eina.Error.RaiseIfUnhandledException();
 523                   return _ret_var;
 524  }
 525    /// <summary>This will fetch the data from a registered node.
 526    /// Be aware this function will trigger a computation of all dirty nodes.
 527    /// 1.20</summary>
 528    /// <param name="child">The child object to inspect.
 529    /// 1.20</param>
 530    /// <returns>The list of relations starting from <c>child</c>.
 531    /// 1.20</returns>
 532    virtual public Efl.Ui.Focus.Relations Fetch( Efl.Ui.Focus.Object child) {
 533                          var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_fetch_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child);
 534       Eina.Error.RaiseIfUnhandledException();
 535                   var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Ui.Focus.Relations>(_ret_var);
 536       Marshal.FreeHGlobal(_ret_var);
 537       return __ret_tmp;
 538  }
 539    /// <summary>Return the last logical object.
 540    /// The returned object is the last object that would be returned if you start at the root and move the direction into next.
 541    /// 1.20</summary>
 542    /// <returns>Last object.
 543    /// 1.20</returns>
 544    virtual public Efl.Ui.Focus.ManagerLogicalEndDetail LogicalEnd() {
 545        var _ret_var = Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_logical_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 546       Eina.Error.RaiseIfUnhandledException();
 547       return Efl.Ui.Focus.ManagerLogicalEndDetail_StructConversion.ToManaged(_ret_var);
 548  }
 549    /// <summary>Reset the history stack of this manager object. This means the uppermost element will be unfocused, and all other elements will be removed from the remembered list.
 550    /// You should focus another element immediately after calling this, in order to always have a focused object.
 551    /// 1.20</summary>
 552    /// <returns></returns>
 553    virtual public  void ResetHistory() {
 554        Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_reset_history_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 555       Eina.Error.RaiseIfUnhandledException();
 556        }
 557    /// <summary>Remove the uppermost history element, and focus the previous one.
 558    /// If there is an element that was focused before, it will be used. Otherwise, the best fitting element from the registered elements will be focused.
 559    /// 1.20</summary>
 560    /// <returns></returns>
 561    virtual public  void PopHistoryStack() {
 562        Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 563       Eina.Error.RaiseIfUnhandledException();
 564        }
 565    /// <summary>Called when this manager is set as redirect.
 566    /// In case that this is called as an result of a move call, <c>direction</c> and <c>entry</c> will be set to the direction of the move call, and the <c>entry</c> object will be set to the object that had this manager as redirect property.
 567    /// 1.20</summary>
 568    /// <param name="direction">The direction in which this should be setup.
 569    /// 1.20</param>
 570    /// <param name="entry">The object that caused this manager to be redirect.
 571    /// 1.20</param>
 572    /// <returns></returns>
 573    virtual public  void SetupOnFirstTouch( Efl.Ui.Focus.Direction direction,  Efl.Ui.Focus.Object entry) {
 574                                            Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_setup_on_first_touch_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), direction,  entry);
 575       Eina.Error.RaiseIfUnhandledException();
 576                                }
 577    /// <summary>This disables the cache invalidation when an object is moved.
 578    /// Even if an object is moved, the focus manager will not recalculate its relations. This can be used when you know that the set of widgets in the focus manager is moved the same way, so the relations between the widets in the set do not change and the complex calculations can be avoided. Use <see cref="Efl.Ui.Focus.Manager.DirtyLogicUnfreeze"/> to re-enable relationship calculation.
 579    /// 1.20</summary>
 580    /// <returns></returns>
 581    virtual public  void FreezeDirtyLogic() {
 582        Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 583       Eina.Error.RaiseIfUnhandledException();
 584        }
 585    /// <summary>This enables the cache invalidation when an object is moved.
 586    /// This is the counterpart to <see cref="Efl.Ui.Focus.Manager.FreezeDirtyLogic"/>.
 587    /// 1.20</summary>
 588    /// <returns></returns>
 589    virtual public  void DirtyLogicUnfreeze() {
 590        Efl.Ui.Focus.ManagerNativeInherit.efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 591       Eina.Error.RaiseIfUnhandledException();
 592        }
 593    /// <summary>The element which is currently focused by this manager
 594 /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
 595 /// 1.20</summary>
 596 /// <value>Currently focused element.
 597 /// 1.20</value>
 598    public Efl.Ui.Focus.Object ManagerFocus {
 599       get { return GetManagerFocus(); }
 600       set { SetManagerFocus( value); }
 601    }
 602    /// <summary>Add another manager to serve the move requests.
 603 /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
 604 /// 1.20</summary>
 605 /// <value>The redirect manager.
 606 /// 1.20</value>
 607    public Efl.Ui.Focus.Manager Redirect {
 608       get { return GetRedirect(); }
 609       set { SetRedirect( value); }
 610    }
 611    /// <summary>The list of elements which are at the border of the graph.
 612 /// This means one of the relations right,left or down,up are not set. This call flushes all changes. See <see cref="Efl.Ui.Focus.Manager.Move"/>
 613 /// 1.20</summary>
 614 /// <value>An iterator over the border objects.
 615 /// 1.20</value>
 616    public Eina.Iterator<Efl.Ui.Focus.Object> BorderElements {
 617       get { return GetBorderElements(); }
 618    }
 619    /// <summary>Root node for all logical subtrees.
 620 /// This property can only be set once.
 621 /// 1.20</summary>
 622 /// <value>Will be registered into this manager object.
 623 /// 1.20</value>
 624    public Efl.Ui.Focus.Object Root {
 625       get { return GetRoot(); }
 626       set { SetRoot( value); }
 627    }
 628    private static new  IntPtr GetEflClassStatic()
 629    {
 630       return Efl.Ui.Focus.ManagerCalc.efl_ui_focus_manager_calc_class_get();
 631    }
 632 }
 633 public class ManagerCalcNativeInherit : Efl.ObjectNativeInherit{
 634    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 635    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 636    {
 637       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 638       if (efl_ui_focus_manager_calc_register_static_delegate == null)
 639       efl_ui_focus_manager_calc_register_static_delegate = new efl_ui_focus_manager_calc_register_delegate(register);
 640       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_register"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_register_static_delegate)});
 641       if (efl_ui_focus_manager_calc_register_logical_static_delegate == null)
 642       efl_ui_focus_manager_calc_register_logical_static_delegate = new efl_ui_focus_manager_calc_register_logical_delegate(register_logical);
 643       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_register_logical"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_register_logical_static_delegate)});
 644       if (efl_ui_focus_manager_calc_update_redirect_static_delegate == null)
 645       efl_ui_focus_manager_calc_update_redirect_static_delegate = new efl_ui_focus_manager_calc_update_redirect_delegate(update_redirect);
 646       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_update_redirect"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_update_redirect_static_delegate)});
 647       if (efl_ui_focus_manager_calc_update_parent_static_delegate == null)
 648       efl_ui_focus_manager_calc_update_parent_static_delegate = new efl_ui_focus_manager_calc_update_parent_delegate(update_parent);
 649       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_update_parent"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_update_parent_static_delegate)});
 650       if (efl_ui_focus_manager_calc_update_children_static_delegate == null)
 651       efl_ui_focus_manager_calc_update_children_static_delegate = new efl_ui_focus_manager_calc_update_children_delegate(update_children);
 652       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_update_children"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_update_children_static_delegate)});
 653       if (efl_ui_focus_manager_calc_update_order_static_delegate == null)
 654       efl_ui_focus_manager_calc_update_order_static_delegate = new efl_ui_focus_manager_calc_update_order_delegate(update_order);
 655       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_update_order"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_update_order_static_delegate)});
 656       if (efl_ui_focus_manager_calc_unregister_static_delegate == null)
 657       efl_ui_focus_manager_calc_unregister_static_delegate = new efl_ui_focus_manager_calc_unregister_delegate(unregister);
 658       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_calc_unregister"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_calc_unregister_static_delegate)});
 659       if (efl_ui_focus_manager_focus_get_static_delegate == null)
 660       efl_ui_focus_manager_focus_get_static_delegate = new efl_ui_focus_manager_focus_get_delegate(manager_focus_get);
 661       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_focus_get_static_delegate)});
 662       if (efl_ui_focus_manager_focus_set_static_delegate == null)
 663       efl_ui_focus_manager_focus_set_static_delegate = new efl_ui_focus_manager_focus_set_delegate(manager_focus_set);
 664       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_focus_set_static_delegate)});
 665       if (efl_ui_focus_manager_redirect_get_static_delegate == null)
 666       efl_ui_focus_manager_redirect_get_static_delegate = new efl_ui_focus_manager_redirect_get_delegate(redirect_get);
 667       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_redirect_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_redirect_get_static_delegate)});
 668       if (efl_ui_focus_manager_redirect_set_static_delegate == null)
 669       efl_ui_focus_manager_redirect_set_static_delegate = new efl_ui_focus_manager_redirect_set_delegate(redirect_set);
 670       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_redirect_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_redirect_set_static_delegate)});
 671       if (efl_ui_focus_manager_border_elements_get_static_delegate == null)
 672       efl_ui_focus_manager_border_elements_get_static_delegate = new efl_ui_focus_manager_border_elements_get_delegate(border_elements_get);
 673       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_border_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_border_elements_get_static_delegate)});
 674       if (efl_ui_focus_manager_viewport_elements_get_static_delegate == null)
 675       efl_ui_focus_manager_viewport_elements_get_static_delegate = new efl_ui_focus_manager_viewport_elements_get_delegate(viewport_elements_get);
 676       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_viewport_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_viewport_elements_get_static_delegate)});
 677       if (efl_ui_focus_manager_root_get_static_delegate == null)
 678       efl_ui_focus_manager_root_get_static_delegate = new efl_ui_focus_manager_root_get_delegate(root_get);
 679       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_root_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_root_get_static_delegate)});
 680       if (efl_ui_focus_manager_root_set_static_delegate == null)
 681       efl_ui_focus_manager_root_set_static_delegate = new efl_ui_focus_manager_root_set_delegate(root_set);
 682       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_root_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_root_set_static_delegate)});
 683       if (efl_ui_focus_manager_move_static_delegate == null)
 684       efl_ui_focus_manager_move_static_delegate = new efl_ui_focus_manager_move_delegate(move);
 685       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_move_static_delegate)});
 686       if (efl_ui_focus_manager_request_move_static_delegate == null)
 687       efl_ui_focus_manager_request_move_static_delegate = new efl_ui_focus_manager_request_move_delegate(request_move);
 688       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_request_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_request_move_static_delegate)});
 689       if (efl_ui_focus_manager_request_subchild_static_delegate == null)
 690       efl_ui_focus_manager_request_subchild_static_delegate = new efl_ui_focus_manager_request_subchild_delegate(request_subchild);
 691       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_request_subchild"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_request_subchild_static_delegate)});
 692       if (efl_ui_focus_manager_fetch_static_delegate == null)
 693       efl_ui_focus_manager_fetch_static_delegate = new efl_ui_focus_manager_fetch_delegate(fetch);
 694       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_fetch"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_fetch_static_delegate)});
 695       if (efl_ui_focus_manager_logical_end_static_delegate == null)
 696       efl_ui_focus_manager_logical_end_static_delegate = new efl_ui_focus_manager_logical_end_delegate(logical_end);
 697       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_logical_end"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_logical_end_static_delegate)});
 698       if (efl_ui_focus_manager_reset_history_static_delegate == null)
 699       efl_ui_focus_manager_reset_history_static_delegate = new efl_ui_focus_manager_reset_history_delegate(reset_history);
 700       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_reset_history"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_reset_history_static_delegate)});
 701       if (efl_ui_focus_manager_pop_history_stack_static_delegate == null)
 702       efl_ui_focus_manager_pop_history_stack_static_delegate = new efl_ui_focus_manager_pop_history_stack_delegate(pop_history_stack);
 703       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_pop_history_stack"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_pop_history_stack_static_delegate)});
 704       if (efl_ui_focus_manager_setup_on_first_touch_static_delegate == null)
 705       efl_ui_focus_manager_setup_on_first_touch_static_delegate = new efl_ui_focus_manager_setup_on_first_touch_delegate(setup_on_first_touch);
 706       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_setup_on_first_touch"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_setup_on_first_touch_static_delegate)});
 707       if (efl_ui_focus_manager_dirty_logic_freeze_static_delegate == null)
 708       efl_ui_focus_manager_dirty_logic_freeze_static_delegate = new efl_ui_focus_manager_dirty_logic_freeze_delegate(dirty_logic_freeze);
 709       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_dirty_logic_freeze"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_dirty_logic_freeze_static_delegate)});
 710       if (efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate == null)
 711       efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate = new efl_ui_focus_manager_dirty_logic_unfreeze_delegate(dirty_logic_unfreeze);
 712       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_manager_dirty_logic_unfreeze"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate)});
 713       descs.AddRange(base.GetEoOps(type));
 714       return descs;
 715    }
 716    public override IntPtr GetEflClass()
 717    {
 718       return Efl.Ui.Focus.ManagerCalc.efl_ui_focus_manager_calc_class_get();
 719    }
 720    public static new  IntPtr GetEflClassStatic()
 721    {
 722       return Efl.Ui.Focus.ManagerCalc.efl_ui_focus_manager_calc_class_get();
 723    }
 724
 725
 726     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_calc_register_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 727
 728
 729     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_calc_register_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 730     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_register_api_delegate> efl_ui_focus_manager_calc_register_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_register_api_delegate>(_Module, "efl_ui_focus_manager_calc_register");
 731     private static bool register(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent,  Efl.Ui.Focus.Manager redirect)
 732    {
 733       Eina.Log.Debug("function efl_ui_focus_manager_calc_register was called");
 734       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 735       if(wrapper != null) {
 736                                                                         bool _ret_var = default(bool);
 737          try {
 738             _ret_var = ((ManagerCalc)wrapper).Register( child,  parent,  redirect);
 739          } catch (Exception e) {
 740             Eina.Log.Warning($"Callback error: {e.ToString()}");
 741             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 742          }
 743                                           return _ret_var;
 744       } else {
 745          return efl_ui_focus_manager_calc_register_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  parent,  redirect);
 746       }
 747    }
 748    private static efl_ui_focus_manager_calc_register_delegate efl_ui_focus_manager_calc_register_static_delegate;
 749
 750
 751     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_calc_register_logical_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 752
 753
 754     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_calc_register_logical_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 755     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_register_logical_api_delegate> efl_ui_focus_manager_calc_register_logical_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_register_logical_api_delegate>(_Module, "efl_ui_focus_manager_calc_register_logical");
 756     private static bool register_logical(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent,  Efl.Ui.Focus.Manager redirect)
 757    {
 758       Eina.Log.Debug("function efl_ui_focus_manager_calc_register_logical was called");
 759       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 760       if(wrapper != null) {
 761                                                                         bool _ret_var = default(bool);
 762          try {
 763             _ret_var = ((ManagerCalc)wrapper).RegisterLogical( child,  parent,  redirect);
 764          } catch (Exception e) {
 765             Eina.Log.Warning($"Callback error: {e.ToString()}");
 766             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 767          }
 768                                           return _ret_var;
 769       } else {
 770          return efl_ui_focus_manager_calc_register_logical_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  parent,  redirect);
 771       }
 772    }
 773    private static efl_ui_focus_manager_calc_register_logical_delegate efl_ui_focus_manager_calc_register_logical_static_delegate;
 774
 775
 776     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_calc_update_redirect_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 777
 778
 779     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_calc_update_redirect_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 780     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_redirect_api_delegate> efl_ui_focus_manager_calc_update_redirect_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_redirect_api_delegate>(_Module, "efl_ui_focus_manager_calc_update_redirect");
 781     private static bool update_redirect(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Manager redirect)
 782    {
 783       Eina.Log.Debug("function efl_ui_focus_manager_calc_update_redirect was called");
 784       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 785       if(wrapper != null) {
 786                                                       bool _ret_var = default(bool);
 787          try {
 788             _ret_var = ((ManagerCalc)wrapper).UpdateRedirect( child,  redirect);
 789          } catch (Exception e) {
 790             Eina.Log.Warning($"Callback error: {e.ToString()}");
 791             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 792          }
 793                               return _ret_var;
 794       } else {
 795          return efl_ui_focus_manager_calc_update_redirect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  redirect);
 796       }
 797    }
 798    private static efl_ui_focus_manager_calc_update_redirect_delegate efl_ui_focus_manager_calc_update_redirect_static_delegate;
 799
 800
 801     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_calc_update_parent_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent);
 802
 803
 804     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_calc_update_parent_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent);
 805     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_parent_api_delegate> efl_ui_focus_manager_calc_update_parent_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_parent_api_delegate>(_Module, "efl_ui_focus_manager_calc_update_parent");
 806     private static bool update_parent(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child,  Efl.Ui.Focus.Object parent)
 807    {
 808       Eina.Log.Debug("function efl_ui_focus_manager_calc_update_parent was called");
 809       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 810       if(wrapper != null) {
 811                                                       bool _ret_var = default(bool);
 812          try {
 813             _ret_var = ((ManagerCalc)wrapper).UpdateParent( child,  parent);
 814          } catch (Exception e) {
 815             Eina.Log.Warning($"Callback error: {e.ToString()}");
 816             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 817          }
 818                               return _ret_var;
 819       } else {
 820          return efl_ui_focus_manager_calc_update_parent_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  parent);
 821       }
 822    }
 823    private static efl_ui_focus_manager_calc_update_parent_delegate efl_ui_focus_manager_calc_update_parent_static_delegate;
 824
 825
 826     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_calc_update_children_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent,    System.IntPtr children);
 827
 828
 829     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_calc_update_children_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent,    System.IntPtr children);
 830     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_children_api_delegate> efl_ui_focus_manager_calc_update_children_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_children_api_delegate>(_Module, "efl_ui_focus_manager_calc_update_children");
 831     private static bool update_children(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object parent,   System.IntPtr children)
 832    {
 833       Eina.Log.Debug("function efl_ui_focus_manager_calc_update_children was called");
 834       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 835       if(wrapper != null) {
 836                      var _in_children = new Eina.List<Efl.Ui.Focus.Object>(children, true, false);
 837                                  bool _ret_var = default(bool);
 838          try {
 839             _ret_var = ((ManagerCalc)wrapper).UpdateChildren( parent,  _in_children);
 840          } catch (Exception e) {
 841             Eina.Log.Warning($"Callback error: {e.ToString()}");
 842             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 843          }
 844                               return _ret_var;
 845       } else {
 846          return efl_ui_focus_manager_calc_update_children_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  parent,  children);
 847       }
 848    }
 849    private static efl_ui_focus_manager_calc_update_children_delegate efl_ui_focus_manager_calc_update_children_static_delegate;
 850
 851
 852     private delegate  void efl_ui_focus_manager_calc_update_order_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent,    System.IntPtr children);
 853
 854
 855     public delegate  void efl_ui_focus_manager_calc_update_order_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object parent,    System.IntPtr children);
 856     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_order_api_delegate> efl_ui_focus_manager_calc_update_order_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_update_order_api_delegate>(_Module, "efl_ui_focus_manager_calc_update_order");
 857     private static  void update_order(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object parent,   System.IntPtr children)
 858    {
 859       Eina.Log.Debug("function efl_ui_focus_manager_calc_update_order was called");
 860       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 861       if(wrapper != null) {
 862                      var _in_children = new Eina.List<Efl.Ui.Focus.Object>(children, true, false);
 863
 864          try {
 865             ((ManagerCalc)wrapper).UpdateOrder( parent,  _in_children);
 866          } catch (Exception e) {
 867             Eina.Log.Warning($"Callback error: {e.ToString()}");
 868             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 869          }
 870                                     } else {
 871          efl_ui_focus_manager_calc_update_order_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  parent,  children);
 872       }
 873    }
 874    private static efl_ui_focus_manager_calc_update_order_delegate efl_ui_focus_manager_calc_update_order_static_delegate;
 875
 876
 877     private delegate  void efl_ui_focus_manager_calc_unregister_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child);
 878
 879
 880     public delegate  void efl_ui_focus_manager_calc_unregister_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child);
 881     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_unregister_api_delegate> efl_ui_focus_manager_calc_unregister_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_calc_unregister_api_delegate>(_Module, "efl_ui_focus_manager_calc_unregister");
 882     private static  void unregister(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child)
 883    {
 884       Eina.Log.Debug("function efl_ui_focus_manager_calc_unregister was called");
 885       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 886       if(wrapper != null) {
 887
 888          try {
 889             ((ManagerCalc)wrapper).Unregister( child);
 890          } catch (Exception e) {
 891             Eina.Log.Warning($"Callback error: {e.ToString()}");
 892             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 893          }
 894                         } else {
 895          efl_ui_focus_manager_calc_unregister_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child);
 896       }
 897    }
 898    private static efl_ui_focus_manager_calc_unregister_delegate efl_ui_focus_manager_calc_unregister_static_delegate;
 899
 900
 901    [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_manager_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
 902
 903
 904    [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_manager_focus_get_api_delegate(System.IntPtr obj);
 905     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_get_api_delegate> efl_ui_focus_manager_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_get_api_delegate>(_Module, "efl_ui_focus_manager_focus_get");
 906     private static Efl.Ui.Focus.Object manager_focus_get(System.IntPtr obj, System.IntPtr pd)
 907    {
 908       Eina.Log.Debug("function efl_ui_focus_manager_focus_get was called");
 909       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 910       if(wrapper != null) {
 911                   Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
 912          try {
 913             _ret_var = ((ManagerCalc)wrapper).GetManagerFocus();
 914          } catch (Exception e) {
 915             Eina.Log.Warning($"Callback error: {e.ToString()}");
 916             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 917          }
 918       return _ret_var;
 919       } else {
 920          return efl_ui_focus_manager_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 921       }
 922    }
 923    private static efl_ui_focus_manager_focus_get_delegate efl_ui_focus_manager_focus_get_static_delegate;
 924
 925
 926     private delegate  void efl_ui_focus_manager_focus_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object focus);
 927
 928
 929     public delegate  void efl_ui_focus_manager_focus_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object focus);
 930     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_set_api_delegate> efl_ui_focus_manager_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_set_api_delegate>(_Module, "efl_ui_focus_manager_focus_set");
 931     private static  void manager_focus_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object focus)
 932    {
 933       Eina.Log.Debug("function efl_ui_focus_manager_focus_set was called");
 934       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 935       if(wrapper != null) {
 936
 937          try {
 938             ((ManagerCalc)wrapper).SetManagerFocus( focus);
 939          } catch (Exception e) {
 940             Eina.Log.Warning($"Callback error: {e.ToString()}");
 941             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 942          }
 943                         } else {
 944          efl_ui_focus_manager_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  focus);
 945       }
 946    }
 947    private static efl_ui_focus_manager_focus_set_delegate efl_ui_focus_manager_focus_set_static_delegate;
 948
 949
 950    [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_manager_redirect_get_delegate(System.IntPtr obj, System.IntPtr pd);
 951
 952
 953    [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_manager_redirect_get_api_delegate(System.IntPtr obj);
 954     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_get_api_delegate> efl_ui_focus_manager_redirect_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_get_api_delegate>(_Module, "efl_ui_focus_manager_redirect_get");
 955     private static Efl.Ui.Focus.Manager redirect_get(System.IntPtr obj, System.IntPtr pd)
 956    {
 957       Eina.Log.Debug("function efl_ui_focus_manager_redirect_get was called");
 958       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 959       if(wrapper != null) {
 960                   Efl.Ui.Focus.Manager _ret_var = default(Efl.Ui.Focus.Manager);
 961          try {
 962             _ret_var = ((ManagerCalc)wrapper).GetRedirect();
 963          } catch (Exception e) {
 964             Eina.Log.Warning($"Callback error: {e.ToString()}");
 965             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 966          }
 967       return _ret_var;
 968       } else {
 969          return efl_ui_focus_manager_redirect_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 970       }
 971    }
 972    private static efl_ui_focus_manager_redirect_get_delegate efl_ui_focus_manager_redirect_get_static_delegate;
 973
 974
 975     private delegate  void efl_ui_focus_manager_redirect_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 976
 977
 978     public delegate  void efl_ui_focus_manager_redirect_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ManagerConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Manager redirect);
 979     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_set_api_delegate> efl_ui_focus_manager_redirect_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_set_api_delegate>(_Module, "efl_ui_focus_manager_redirect_set");
 980     private static  void redirect_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Manager redirect)
 981    {
 982       Eina.Log.Debug("function efl_ui_focus_manager_redirect_set was called");
 983       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 984       if(wrapper != null) {
 985
 986          try {
 987             ((ManagerCalc)wrapper).SetRedirect( redirect);
 988          } catch (Exception e) {
 989             Eina.Log.Warning($"Callback error: {e.ToString()}");
 990             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 991          }
 992                         } else {
 993          efl_ui_focus_manager_redirect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  redirect);
 994       }
 995    }
 996    private static efl_ui_focus_manager_redirect_set_delegate efl_ui_focus_manager_redirect_set_static_delegate;
 997
 998
 999     private delegate  System.IntPtr efl_ui_focus_manager_border_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
1000
1001
1002     public delegate  System.IntPtr efl_ui_focus_manager_border_elements_get_api_delegate(System.IntPtr obj);
1003     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_border_elements_get_api_delegate> efl_ui_focus_manager_border_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_border_elements_get_api_delegate>(_Module, "efl_ui_focus_manager_border_elements_get");
1004     private static  System.IntPtr border_elements_get(System.IntPtr obj, System.IntPtr pd)
1005    {
1006       Eina.Log.Debug("function efl_ui_focus_manager_border_elements_get was called");
1007       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1008       if(wrapper != null) {
1009                   Eina.Iterator<Efl.Ui.Focus.Object> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.Object>);
1010          try {
1011             _ret_var = ((ManagerCalc)wrapper).GetBorderElements();
1012          } catch (Exception e) {
1013             Eina.Log.Warning($"Callback error: {e.ToString()}");
1014             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1015          }
1016       return _ret_var.Handle;
1017       } else {
1018          return efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1019       }
1020    }
1021    private static efl_ui_focus_manager_border_elements_get_delegate efl_ui_focus_manager_border_elements_get_static_delegate;
1022
1023
1024     private delegate  System.IntPtr efl_ui_focus_manager_viewport_elements_get_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect_StructInternal viewport);
1025
1026
1027     public delegate  System.IntPtr efl_ui_focus_manager_viewport_elements_get_api_delegate(System.IntPtr obj,   Eina.Rect_StructInternal viewport);
1028     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_viewport_elements_get_api_delegate> efl_ui_focus_manager_viewport_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_viewport_elements_get_api_delegate>(_Module, "efl_ui_focus_manager_viewport_elements_get");
1029     private static  System.IntPtr viewport_elements_get(System.IntPtr obj, System.IntPtr pd,  Eina.Rect_StructInternal viewport)
1030    {
1031       Eina.Log.Debug("function efl_ui_focus_manager_viewport_elements_get was called");
1032       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1033       if(wrapper != null) {
1034                var _in_viewport = Eina.Rect_StructConversion.ToManaged(viewport);
1035                      Eina.Iterator<Efl.Ui.Focus.Object> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.Object>);
1036          try {
1037             _ret_var = ((ManagerCalc)wrapper).GetViewportElements( _in_viewport);
1038          } catch (Exception e) {
1039             Eina.Log.Warning($"Callback error: {e.ToString()}");
1040             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1041          }
1042                   return _ret_var.Handle;
1043       } else {
1044          return efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  viewport);
1045       }
1046    }
1047    private static efl_ui_focus_manager_viewport_elements_get_delegate efl_ui_focus_manager_viewport_elements_get_static_delegate;
1048
1049
1050    [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_manager_root_get_delegate(System.IntPtr obj, System.IntPtr pd);
1051
1052
1053    [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_manager_root_get_api_delegate(System.IntPtr obj);
1054     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_get_api_delegate> efl_ui_focus_manager_root_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_get_api_delegate>(_Module, "efl_ui_focus_manager_root_get");
1055     private static Efl.Ui.Focus.Object root_get(System.IntPtr obj, System.IntPtr pd)
1056    {
1057       Eina.Log.Debug("function efl_ui_focus_manager_root_get was called");
1058       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1059       if(wrapper != null) {
1060                   Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
1061          try {
1062             _ret_var = ((ManagerCalc)wrapper).GetRoot();
1063          } catch (Exception e) {
1064             Eina.Log.Warning($"Callback error: {e.ToString()}");
1065             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1066          }
1067       return _ret_var;
1068       } else {
1069          return efl_ui_focus_manager_root_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1070       }
1071    }
1072    private static efl_ui_focus_manager_root_get_delegate efl_ui_focus_manager_root_get_static_delegate;
1073
1074
1075     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_manager_root_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object root);
1076
1077
1078     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_manager_root_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object root);
1079     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_set_api_delegate> efl_ui_focus_manager_root_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_set_api_delegate>(_Module, "efl_ui_focus_manager_root_set");
1080     private static bool root_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object root)
1081    {
1082       Eina.Log.Debug("function efl_ui_focus_manager_root_set was called");
1083       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1084       if(wrapper != null) {
1085                                     bool _ret_var = default(bool);
1086          try {
1087             _ret_var = ((ManagerCalc)wrapper).SetRoot( root);
1088          } catch (Exception e) {
1089             Eina.Log.Warning($"Callback error: {e.ToString()}");
1090             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1091          }
1092                   return _ret_var;
1093       } else {
1094          return efl_ui_focus_manager_root_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  root);
1095       }
1096    }
1097    private static efl_ui_focus_manager_root_set_delegate efl_ui_focus_manager_root_set_static_delegate;
1098
1099
1100    [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_manager_move_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction direction);
1101
1102
1103    [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_manager_move_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction direction);
1104     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_move_api_delegate> efl_ui_focus_manager_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_move_api_delegate>(_Module, "efl_ui_focus_manager_move");
1105     private static Efl.Ui.Focus.Object move(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction)
1106    {
1107       Eina.Log.Debug("function efl_ui_focus_manager_move was called");
1108       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1109       if(wrapper != null) {
1110                                     Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
1111          try {
1112             _ret_var = ((ManagerCalc)wrapper).Move( direction);
1113          } catch (Exception e) {
1114             Eina.Log.Warning($"Callback error: {e.ToString()}");
1115             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1116          }
1117                   return _ret_var;
1118       } else {
1119          return efl_ui_focus_manager_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  direction);
1120       }
1121    }
1122    private static efl_ui_focus_manager_move_delegate efl_ui_focus_manager_move_static_delegate;
1123
1124
1125    [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_manager_request_move_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child,  [MarshalAs(UnmanagedType.U1)]  bool logical);
1126
1127
1128    [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_manager_request_move_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child,  [MarshalAs(UnmanagedType.U1)]  bool logical);
1129     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_move_api_delegate> efl_ui_focus_manager_request_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_move_api_delegate>(_Module, "efl_ui_focus_manager_request_move");
1130     private static Efl.Ui.Focus.Object request_move(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction,  Efl.Ui.Focus.Object child,  bool logical)
1131    {
1132       Eina.Log.Debug("function efl_ui_focus_manager_request_move was called");
1133       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1134       if(wrapper != null) {
1135                                                                         Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
1136          try {
1137             _ret_var = ((ManagerCalc)wrapper).MoveRequest( direction,  child,  logical);
1138          } catch (Exception e) {
1139             Eina.Log.Warning($"Callback error: {e.ToString()}");
1140             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1141          }
1142                                           return _ret_var;
1143       } else {
1144          return efl_ui_focus_manager_request_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  direction,  child,  logical);
1145       }
1146    }
1147    private static efl_ui_focus_manager_request_move_delegate efl_ui_focus_manager_request_move_static_delegate;
1148
1149
1150    [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_manager_request_subchild_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object root);
1151
1152
1153    [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_manager_request_subchild_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object root);
1154     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_subchild_api_delegate> efl_ui_focus_manager_request_subchild_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_subchild_api_delegate>(_Module, "efl_ui_focus_manager_request_subchild");
1155     private static Efl.Ui.Focus.Object request_subchild(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object root)
1156    {
1157       Eina.Log.Debug("function efl_ui_focus_manager_request_subchild was called");
1158       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1159       if(wrapper != null) {
1160                                     Efl.Ui.Focus.Object _ret_var = default(Efl.Ui.Focus.Object);
1161          try {
1162             _ret_var = ((ManagerCalc)wrapper).RequestSubchild( root);
1163          } catch (Exception e) {
1164             Eina.Log.Warning($"Callback error: {e.ToString()}");
1165             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1166          }
1167                   return _ret_var;
1168       } else {
1169          return efl_ui_focus_manager_request_subchild_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  root);
1170       }
1171    }
1172    private static efl_ui_focus_manager_request_subchild_delegate efl_ui_focus_manager_request_subchild_static_delegate;
1173
1174
1175     private delegate  System.IntPtr efl_ui_focus_manager_fetch_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child);
1176
1177
1178     public delegate  System.IntPtr efl_ui_focus_manager_fetch_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object child);
1179     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_fetch_api_delegate> efl_ui_focus_manager_fetch_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_fetch_api_delegate>(_Module, "efl_ui_focus_manager_fetch");
1180     private static  System.IntPtr fetch(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Object child)
1181    {
1182       Eina.Log.Debug("function efl_ui_focus_manager_fetch was called");
1183       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1184       if(wrapper != null) {
1185                                     Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
1186          try {
1187             _ret_var = ((ManagerCalc)wrapper).Fetch( child);
1188          } catch (Exception e) {
1189             Eina.Log.Warning($"Callback error: {e.ToString()}");
1190             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1191          }
1192                   return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
1193       } else {
1194          return efl_ui_focus_manager_fetch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child);
1195       }
1196    }
1197    private static efl_ui_focus_manager_fetch_delegate efl_ui_focus_manager_fetch_static_delegate;
1198
1199
1200     private delegate Efl.Ui.Focus.ManagerLogicalEndDetail_StructInternal efl_ui_focus_manager_logical_end_delegate(System.IntPtr obj, System.IntPtr pd);
1201
1202
1203     public delegate Efl.Ui.Focus.ManagerLogicalEndDetail_StructInternal efl_ui_focus_manager_logical_end_api_delegate(System.IntPtr obj);
1204     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_logical_end_api_delegate> efl_ui_focus_manager_logical_end_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_logical_end_api_delegate>(_Module, "efl_ui_focus_manager_logical_end");
1205     private static Efl.Ui.Focus.ManagerLogicalEndDetail_StructInternal logical_end(System.IntPtr obj, System.IntPtr pd)
1206    {
1207       Eina.Log.Debug("function efl_ui_focus_manager_logical_end was called");
1208       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1209       if(wrapper != null) {
1210                   Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
1211          try {
1212             _ret_var = ((ManagerCalc)wrapper).LogicalEnd();
1213          } catch (Exception e) {
1214             Eina.Log.Warning($"Callback error: {e.ToString()}");
1215             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1216          }
1217       return Efl.Ui.Focus.ManagerLogicalEndDetail_StructConversion.ToInternal(_ret_var);
1218       } else {
1219          return efl_ui_focus_manager_logical_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1220       }
1221    }
1222    private static efl_ui_focus_manager_logical_end_delegate efl_ui_focus_manager_logical_end_static_delegate;
1223
1224
1225     private delegate  void efl_ui_focus_manager_reset_history_delegate(System.IntPtr obj, System.IntPtr pd);
1226
1227
1228     public delegate  void efl_ui_focus_manager_reset_history_api_delegate(System.IntPtr obj);
1229     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_reset_history_api_delegate> efl_ui_focus_manager_reset_history_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_reset_history_api_delegate>(_Module, "efl_ui_focus_manager_reset_history");
1230     private static  void reset_history(System.IntPtr obj, System.IntPtr pd)
1231    {
1232       Eina.Log.Debug("function efl_ui_focus_manager_reset_history was called");
1233       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1234       if(wrapper != null) {
1235
1236          try {
1237             ((ManagerCalc)wrapper).ResetHistory();
1238          } catch (Exception e) {
1239             Eina.Log.Warning($"Callback error: {e.ToString()}");
1240             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1241          }
1242             } else {
1243          efl_ui_focus_manager_reset_history_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1244       }
1245    }
1246    private static efl_ui_focus_manager_reset_history_delegate efl_ui_focus_manager_reset_history_static_delegate;
1247
1248
1249     private delegate  void efl_ui_focus_manager_pop_history_stack_delegate(System.IntPtr obj, System.IntPtr pd);
1250
1251
1252     public delegate  void efl_ui_focus_manager_pop_history_stack_api_delegate(System.IntPtr obj);
1253     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_pop_history_stack_api_delegate> efl_ui_focus_manager_pop_history_stack_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_pop_history_stack_api_delegate>(_Module, "efl_ui_focus_manager_pop_history_stack");
1254     private static  void pop_history_stack(System.IntPtr obj, System.IntPtr pd)
1255    {
1256       Eina.Log.Debug("function efl_ui_focus_manager_pop_history_stack was called");
1257       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1258       if(wrapper != null) {
1259
1260          try {
1261             ((ManagerCalc)wrapper).PopHistoryStack();
1262          } catch (Exception e) {
1263             Eina.Log.Warning($"Callback error: {e.ToString()}");
1264             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1265          }
1266             } else {
1267          efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1268       }
1269    }
1270    private static efl_ui_focus_manager_pop_history_stack_delegate efl_ui_focus_manager_pop_history_stack_static_delegate;
1271
1272
1273     private delegate  void efl_ui_focus_manager_setup_on_first_touch_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object entry);
1274
1275
1276     public delegate  void efl_ui_focus_manager_setup_on_first_touch_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.ObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Ui.Focus.Object entry);
1277     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_setup_on_first_touch_api_delegate> efl_ui_focus_manager_setup_on_first_touch_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_setup_on_first_touch_api_delegate>(_Module, "efl_ui_focus_manager_setup_on_first_touch");
1278     private static  void setup_on_first_touch(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction,  Efl.Ui.Focus.Object entry)
1279    {
1280       Eina.Log.Debug("function efl_ui_focus_manager_setup_on_first_touch was called");
1281       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1282       if(wrapper != null) {
1283
1284          try {
1285             ((ManagerCalc)wrapper).SetupOnFirstTouch( direction,  entry);
1286          } catch (Exception e) {
1287             Eina.Log.Warning($"Callback error: {e.ToString()}");
1288             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1289          }
1290                                     } else {
1291          efl_ui_focus_manager_setup_on_first_touch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  direction,  entry);
1292       }
1293    }
1294    private static efl_ui_focus_manager_setup_on_first_touch_delegate efl_ui_focus_manager_setup_on_first_touch_static_delegate;
1295
1296
1297     private delegate  void efl_ui_focus_manager_dirty_logic_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
1298
1299
1300     public delegate  void efl_ui_focus_manager_dirty_logic_freeze_api_delegate(System.IntPtr obj);
1301     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_freeze_api_delegate> efl_ui_focus_manager_dirty_logic_freeze_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_freeze_api_delegate>(_Module, "efl_ui_focus_manager_dirty_logic_freeze");
1302     private static  void dirty_logic_freeze(System.IntPtr obj, System.IntPtr pd)
1303    {
1304       Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_freeze was called");
1305       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1306       if(wrapper != null) {
1307
1308          try {
1309             ((ManagerCalc)wrapper).FreezeDirtyLogic();
1310          } catch (Exception e) {
1311             Eina.Log.Warning($"Callback error: {e.ToString()}");
1312             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1313          }
1314             } else {
1315          efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1316       }
1317    }
1318    private static efl_ui_focus_manager_dirty_logic_freeze_delegate efl_ui_focus_manager_dirty_logic_freeze_static_delegate;
1319
1320
1321     private delegate  void efl_ui_focus_manager_dirty_logic_unfreeze_delegate(System.IntPtr obj, System.IntPtr pd);
1322
1323
1324     public delegate  void efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate(System.IntPtr obj);
1325     public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate> efl_ui_focus_manager_dirty_logic_unfreeze_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate>(_Module, "efl_ui_focus_manager_dirty_logic_unfreeze");
1326     private static  void dirty_logic_unfreeze(System.IntPtr obj, System.IntPtr pd)
1327    {
1328       Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_unfreeze was called");
1329       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1330       if(wrapper != null) {
1331
1332          try {
1333             ((ManagerCalc)wrapper).DirtyLogicUnfreeze();
1334          } catch (Exception e) {
1335             Eina.Log.Warning($"Callback error: {e.ToString()}");
1336             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1337          }
1338             } else {
1339          efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1340       }
1341    }
1342    private static efl_ui_focus_manager_dirty_logic_unfreeze_delegate efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate;
1343 }
1344 } } }