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