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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 namespace Focus {
  13
  14 /// <summary>Calculates the directions of Efl.Ui.Focus.Direction
  15 /// 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>
  16 [Efl.Ui.Focus.ManagerCalc.NativeMethods]
  17 public class ManagerCalc : Efl.Object, Efl.Ui.Focus.IManager
  18 {
  19     ///<summary>Pointer to the native class description.</summary>
  20     public override System.IntPtr NativeClass
  21     {
  22         get
  23         {
  24             if (((object)this).GetType() == typeof(ManagerCalc))
  25             {
  26                 return GetEflClassStatic();
  27             }
  28             else
  29             {
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31             }
  32         }
  33     }
  34
  35     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  36         efl_ui_focus_manager_calc_class_get();
  37     /// <summary>Initializes a new instance of the <see cref="ManagerCalc"/> class.</summary>
  38     /// <param name="parent">Parent instance.</param>
  39     public ManagerCalc(Efl.Object parent= null
  40             ) : base(efl_ui_focus_manager_calc_class_get(), typeof(ManagerCalc), parent)
  41     {
  42         FinishInstantiation();
  43     }
  44
  45     /// <summary>Initializes a new instance of the <see cref="ManagerCalc"/> class.
  46     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  47     /// <param name="raw">The native pointer to be wrapped.</param>
  48     protected ManagerCalc(System.IntPtr raw) : base(raw)
  49     {
  50     }
  51
  52     /// <summary>Initializes a new instance of the <see cref="ManagerCalc"/> class.
  53     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  54     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  55     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  56     /// <param name="parent">The Efl.Object parent of this instance.</param>
  57     protected ManagerCalc(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  58     {
  59     }
  60
  61     /// <summary>Redirect object has changed, the old manager is passed as an event argument.
  62     /// (Since EFL 1.22)</summary>
  63     public event EventHandler<Efl.Ui.Focus.IManagerRedirectChangedEvt_Args> RedirectChangedEvt
  64     {
  65         add
  66         {
  67             lock (eventLock)
  68             {
  69                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  70                 {
  71                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  72                     if (obj != null)
  73                     {
  74                         Efl.Ui.Focus.IManagerRedirectChangedEvt_Args args = new Efl.Ui.Focus.IManagerRedirectChangedEvt_Args();
  75                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IManagerConcrete);
  76                         try
  77                         {
  78                             value?.Invoke(obj, args);
  79                         }
  80                         catch (Exception e)
  81                         {
  82                             Eina.Log.Error(e.ToString());
  83                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  84                         }
  85                     }
  86                 };
  87
  88                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
  89                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  90             }
  91         }
  92
  93         remove
  94         {
  95             lock (eventLock)
  96             {
  97                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
  98                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
  99             }
 100         }
 101     }
 102     ///<summary>Method to raise event RedirectChangedEvt.</summary>
 103     public void OnRedirectChangedEvt(Efl.Ui.Focus.IManagerRedirectChangedEvt_Args e)
 104     {
 105         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
 106         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 107         if (desc == IntPtr.Zero)
 108         {
 109             Eina.Log.Error($"Failed to get native event {key}");
 110             return;
 111         }
 112
 113         IntPtr info = e.arg.NativeHandle;
 114         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 115     }
 116     /// <summary>After this event, the manager object will calculate relations in the graph. Can be used to add / remove children in a lazy fashion.
 117     /// (Since EFL 1.22)</summary>
 118     public event EventHandler FlushPreEvt
 119     {
 120         add
 121         {
 122             lock (eventLock)
 123             {
 124                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 125                 {
 126                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 127                     if (obj != null)
 128                     {
 129                         EventArgs args = EventArgs.Empty;
 130                         try
 131                         {
 132                             value?.Invoke(obj, args);
 133                         }
 134                         catch (Exception e)
 135                         {
 136                             Eina.Log.Error(e.ToString());
 137                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 138                         }
 139                     }
 140                 };
 141
 142                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 143                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 144             }
 145         }
 146
 147         remove
 148         {
 149             lock (eventLock)
 150             {
 151                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 152                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 153             }
 154         }
 155     }
 156     ///<summary>Method to raise event FlushPreEvt.</summary>
 157     public void OnFlushPreEvt(EventArgs e)
 158     {
 159         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 160         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 161         if (desc == IntPtr.Zero)
 162         {
 163             Eina.Log.Error($"Failed to get native event {key}");
 164             return;
 165         }
 166
 167         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 168     }
 169     /// <summary>Cached relationship calculation results have been invalidated.
 170     /// (Since EFL 1.22)</summary>
 171     public event EventHandler CoordsDirtyEvt
 172     {
 173         add
 174         {
 175             lock (eventLock)
 176             {
 177                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 178                 {
 179                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 180                     if (obj != null)
 181                     {
 182                         EventArgs args = EventArgs.Empty;
 183                         try
 184                         {
 185                             value?.Invoke(obj, args);
 186                         }
 187                         catch (Exception e)
 188                         {
 189                             Eina.Log.Error(e.ToString());
 190                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 191                         }
 192                     }
 193                 };
 194
 195                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 196                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 197             }
 198         }
 199
 200         remove
 201         {
 202             lock (eventLock)
 203             {
 204                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 205                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 206             }
 207         }
 208     }
 209     ///<summary>Method to raise event CoordsDirtyEvt.</summary>
 210     public void OnCoordsDirtyEvt(EventArgs e)
 211     {
 212         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 213         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 214         if (desc == IntPtr.Zero)
 215         {
 216             Eina.Log.Error($"Failed to get native event {key}");
 217             return;
 218         }
 219
 220         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 221     }
 222     /// <summary>The manager_focus property has changed. The previously focused object is passed as an event argument.
 223     /// (Since EFL 1.22)</summary>
 224     public event EventHandler<Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args> ManagerFocusChangedEvt
 225     {
 226         add
 227         {
 228             lock (eventLock)
 229             {
 230                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 231                 {
 232                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 233                     if (obj != null)
 234                     {
 235                         Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args args = new Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args();
 236                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IObjectConcrete);
 237                         try
 238                         {
 239                             value?.Invoke(obj, args);
 240                         }
 241                         catch (Exception e)
 242                         {
 243                             Eina.Log.Error(e.ToString());
 244                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 245                         }
 246                     }
 247                 };
 248
 249                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 250                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 251             }
 252         }
 253
 254         remove
 255         {
 256             lock (eventLock)
 257             {
 258                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 259                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 260             }
 261         }
 262     }
 263     ///<summary>Method to raise event ManagerFocusChangedEvt.</summary>
 264     public void OnManagerFocusChangedEvt(Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args e)
 265     {
 266         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 267         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 268         if (desc == IntPtr.Zero)
 269         {
 270             Eina.Log.Error($"Failed to get native event {key}");
 271             return;
 272         }
 273
 274         IntPtr info = e.arg.NativeHandle;
 275         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 276     }
 277     /// <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.
 278     /// (Since EFL 1.22)</summary>
 279     public event EventHandler<Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args> DirtyLogicFreezeChangedEvt
 280     {
 281         add
 282         {
 283             lock (eventLock)
 284             {
 285                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 286                 {
 287                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 288                     if (obj != null)
 289                     {
 290                         Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args args = new Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args();
 291                         args.arg = Marshal.ReadByte(evt.Info) != 0;
 292                         try
 293                         {
 294                             value?.Invoke(obj, args);
 295                         }
 296                         catch (Exception e)
 297                         {
 298                             Eina.Log.Error(e.ToString());
 299                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 300                         }
 301                     }
 302                 };
 303
 304                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 305                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 306             }
 307         }
 308
 309         remove
 310         {
 311             lock (eventLock)
 312             {
 313                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 314                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 315             }
 316         }
 317     }
 318     ///<summary>Method to raise event DirtyLogicFreezeChangedEvt.</summary>
 319     public void OnDirtyLogicFreezeChangedEvt(Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args e)
 320     {
 321         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 322         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 323         if (desc == IntPtr.Zero)
 324         {
 325             Eina.Log.Error($"Failed to get native event {key}");
 326             return;
 327         }
 328
 329         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 330         try
 331         {
 332             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 333         }
 334         finally
 335         {
 336             Marshal.FreeHGlobal(info);
 337         }
 338     }
 339     /// <summary>Register a new item in the graph.
 340     /// <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>
 341     /// <param name="child">The object to register</param>
 342     /// <param name="parent">The parent to use in the logical tree</param>
 343     /// <param name="redirect">The redirect manager to set once this child is focused can be NULL for no redirect</param>
 344     /// <returns><c>true</c> if successful, <c>false</c> otherwise</returns>
 345     virtual public bool Register(Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IObject parent, Efl.Ui.Focus.IManager redirect) {
 346                                                                                  var _ret_var = Efl.Ui.Focus.ManagerCalc.NativeMethods.efl_ui_focus_manager_calc_register_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child, parent, redirect);
 347         Eina.Error.RaiseIfUnhandledException();
 348                                                         return _ret_var;
 349  }
 350     /// <summary>Register a new item only for the logical parent.
 351     /// The item can never get focus, it just helps to build a tree out of the items that are.</summary>
 352     /// <param name="child">The object to register</param>
 353     /// <param name="parent">The parent to use in the logical tree</param>
 354     /// <param name="redirect">The redirect manager to set once this child is focused can be <c>null</c> for no redirect</param>
 355     /// <returns><c>true</c> if successful, <c>false</c> otherwise</returns>
 356     virtual public bool RegisterLogical(Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IObject parent, Efl.Ui.Focus.IManager redirect) {
 357                                                                                  var _ret_var = Efl.Ui.Focus.ManagerCalc.NativeMethods.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);
 358         Eina.Error.RaiseIfUnhandledException();
 359                                                         return _ret_var;
 360  }
 361     /// <summary>Set a new redirect object for the given child.
 362     /// 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>
 363     /// <param name="child">The child to update</param>
 364     /// <param name="redirect">Once <c>child</c> is focused this element will be set as redirect</param>
 365     /// <returns><c>true</c> if successful, <c>false</c> otherwise</returns>
 366     virtual public bool UpdateRedirect(Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IManager redirect) {
 367                                                          var _ret_var = Efl.Ui.Focus.ManagerCalc.NativeMethods.efl_ui_focus_manager_calc_update_redirect_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child, redirect);
 368         Eina.Error.RaiseIfUnhandledException();
 369                                         return _ret_var;
 370  }
 371     /// <summary>Set a new logical parent for the given child.</summary>
 372     /// <param name="child">The child to update</param>
 373     /// <param name="parent">The parent which now will be the logical parent of child</param>
 374     /// <returns><c>true</c> if successful, <c>false</c> otherwise</returns>
 375     virtual public bool UpdateParent(Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IObject parent) {
 376                                                          var _ret_var = Efl.Ui.Focus.ManagerCalc.NativeMethods.efl_ui_focus_manager_calc_update_parent_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child, parent);
 377         Eina.Error.RaiseIfUnhandledException();
 378                                         return _ret_var;
 379  }
 380     /// <summary>Give the list of children a different order.</summary>
 381     /// <param name="parent">the parent to update</param>
 382     /// <param name="children">the list with the new order</param>
 383     /// <returns><c>true</c> if successful, <c>false</c> otherwise</returns>
 384     virtual public bool UpdateChildren(Efl.Ui.Focus.IObject parent, Eina.List<Efl.Ui.Focus.IObject> children) {
 385                  var _in_children = children.Handle;
 386 children.Own = false;
 387                                         var _ret_var = Efl.Ui.Focus.ManagerCalc.NativeMethods.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);
 388         Eina.Error.RaiseIfUnhandledException();
 389                                         return _ret_var;
 390  }
 391     /// <summary>Give the given order to the parent&apos;s child.
 392     /// Children from the list which are not true children are ignored.</summary>
 393     /// <param name="parent">the parent to update</param>
 394     /// <param name="children">the order of items</param>
 395     virtual public void UpdateOrder(Efl.Ui.Focus.IObject parent, Eina.List<Efl.Ui.Focus.IObject> children) {
 396                  var _in_children = children.Handle;
 397 children.Own = false;
 398                                         Efl.Ui.Focus.ManagerCalc.NativeMethods.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);
 399         Eina.Error.RaiseIfUnhandledException();
 400                                          }
 401     /// <summary>Unregister the given item from the focus graph.</summary>
 402     /// <param name="child">The child to unregister.</param>
 403     virtual public void Unregister(Efl.Ui.Focus.IObject child) {
 404                                  Efl.Ui.Focus.ManagerCalc.NativeMethods.efl_ui_focus_manager_calc_unregister_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child);
 405         Eina.Error.RaiseIfUnhandledException();
 406                          }
 407     /// <summary>The element which is currently focused by this manager
 408     /// 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.
 409     /// (Since EFL 1.22)</summary>
 410     /// <returns>Currently focused element.</returns>
 411     virtual public Efl.Ui.Focus.IObject GetManagerFocus() {
 412          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 413         Eina.Error.RaiseIfUnhandledException();
 414         return _ret_var;
 415  }
 416     /// <summary>The element which is currently focused by this manager
 417     /// 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.
 418     /// (Since EFL 1.22)</summary>
 419     /// <param name="focus">Currently focused element.</param>
 420     virtual public void SetManagerFocus(Efl.Ui.Focus.IObject focus) {
 421                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),focus);
 422         Eina.Error.RaiseIfUnhandledException();
 423                          }
 424     /// <summary>Add another manager to serve the move requests.
 425     /// 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.
 426     /// (Since EFL 1.22)</summary>
 427     /// <returns>The redirect manager.</returns>
 428     virtual public Efl.Ui.Focus.IManager GetRedirect() {
 429          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 430         Eina.Error.RaiseIfUnhandledException();
 431         return _ret_var;
 432  }
 433     /// <summary>Add another manager to serve the move requests.
 434     /// 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.
 435     /// (Since EFL 1.22)</summary>
 436     /// <param name="redirect">The redirect manager.</param>
 437     virtual public void SetRedirect(Efl.Ui.Focus.IManager redirect) {
 438                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),redirect);
 439         Eina.Error.RaiseIfUnhandledException();
 440                          }
 441     /// <summary>The list of elements which are at the border of the graph.
 442     /// This means one of the relations right,left or down,up are not set. This call flushes all changes. See <see cref="Efl.Ui.Focus.IManager.Move"/>
 443     /// (Since EFL 1.22)</summary>
 444     /// <returns>An iterator over the border objects.</returns>
 445     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetBorderElements() {
 446          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 447         Eina.Error.RaiseIfUnhandledException();
 448         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false, false);
 449  }
 450     /// <summary>Get all elements that are at the border of the viewport
 451     /// Every element returned by this is located inside the viewport rectangle, but has a right, left, down or up neighbor outside the viewport.
 452     /// (Since EFL 1.22)</summary>
 453     /// <param name="viewport">The rectangle defining the viewport.</param>
 454     /// <returns>The list of border objects.</returns>
 455     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetViewportElements(Eina.Rect viewport) {
 456          Eina.Rect.NativeStruct _in_viewport = viewport;
 457                         var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_viewport);
 458         Eina.Error.RaiseIfUnhandledException();
 459                         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false, false);
 460  }
 461     /// <summary>Root node for all logical subtrees.
 462     /// This property can only be set once.
 463     /// (Since EFL 1.22)</summary>
 464     /// <returns>Will be registered into this manager object.</returns>
 465     virtual public Efl.Ui.Focus.IObject GetRoot() {
 466          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 467         Eina.Error.RaiseIfUnhandledException();
 468         return _ret_var;
 469  }
 470     /// <summary>Root node for all logical subtrees.
 471     /// This property can only be set once.
 472     /// (Since EFL 1.22)</summary>
 473     /// <param name="root">Will be registered into this manager object.</param>
 474     /// <returns>If <c>true</c>, this is the root node</returns>
 475     virtual public bool SetRoot(Efl.Ui.Focus.IObject root) {
 476                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),root);
 477         Eina.Error.RaiseIfUnhandledException();
 478                         return _ret_var;
 479  }
 480     /// <summary>Move the focus in the given direction.
 481     /// This call flushes all changes. This means all changes between the last flush and now are computed.
 482     /// (Since EFL 1.22)</summary>
 483     /// <param name="direction">The direction to move to.</param>
 484     /// <returns>The element which is now focused.</returns>
 485     virtual public Efl.Ui.Focus.IObject Move(Efl.Ui.Focus.Direction direction) {
 486                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),direction);
 487         Eina.Error.RaiseIfUnhandledException();
 488                         return _ret_var;
 489  }
 490     /// <summary>Return the object in the <c>direction</c> from <c>child</c>.
 491     /// (Since EFL 1.22)</summary>
 492     /// <param name="direction">Direction to move focus.</param>
 493     /// <param name="child">The child to move from. Pass <c>null</c> to indicate the currently focused child.</param>
 494     /// <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>
 495     /// <returns>Object that would receive focus if moved in the given direction.</returns>
 496     virtual public Efl.Ui.Focus.IObject MoveRequest(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject child, bool logical) {
 497                                                                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),direction, child, logical);
 498         Eina.Error.RaiseIfUnhandledException();
 499                                                         return _ret_var;
 500  }
 501     /// <summary>Return the widget in the direction next.
 502     /// 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.
 503     /// (Since EFL 1.22)</summary>
 504     /// <param name="root">Parent for returned child.</param>
 505     /// <returns>Child of passed parameter.</returns>
 506     virtual public Efl.Ui.Focus.IObject RequestSubchild(Efl.Ui.Focus.IObject root) {
 507                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_subchild_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),root);
 508         Eina.Error.RaiseIfUnhandledException();
 509                         return _ret_var;
 510  }
 511     /// <summary>This will fetch the data from a registered node.
 512     /// Be aware this function will trigger a computation of all dirty nodes.
 513     /// (Since EFL 1.22)</summary>
 514     /// <param name="child">The child object to inspect.</param>
 515     /// <returns>The list of relations starting from <c>child</c>.</returns>
 516     virtual public Efl.Ui.Focus.Relations Fetch(Efl.Ui.Focus.IObject child) {
 517                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_fetch_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child);
 518         Eina.Error.RaiseIfUnhandledException();
 519                         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Ui.Focus.Relations>(_ret_var);
 520         Marshal.FreeHGlobal(_ret_var);
 521         return __ret_tmp;
 522  }
 523     /// <summary>Return the last logical object.
 524     /// The returned object is the last object that would be returned if you start at the root and move the direction into next.
 525     /// (Since EFL 1.22)</summary>
 526     /// <returns>Last object.</returns>
 527     virtual public Efl.Ui.Focus.ManagerLogicalEndDetail LogicalEnd() {
 528          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_logical_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 529         Eina.Error.RaiseIfUnhandledException();
 530         return _ret_var;
 531  }
 532     /// <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.
 533     /// You should focus another element immediately after calling this, in order to always have a focused object.
 534     /// (Since EFL 1.22)</summary>
 535     virtual public void ResetHistory() {
 536          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_reset_history_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 537         Eina.Error.RaiseIfUnhandledException();
 538          }
 539     /// <summary>Remove the uppermost history element, and focus the previous one.
 540     /// 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.
 541     /// (Since EFL 1.22)</summary>
 542     virtual public void PopHistoryStack() {
 543          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 544         Eina.Error.RaiseIfUnhandledException();
 545          }
 546     /// <summary>Called when this manager is set as redirect.
 547     /// 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.
 548     /// (Since EFL 1.22)</summary>
 549     /// <param name="direction">The direction in which this should be setup.</param>
 550     /// <param name="entry">The object that caused this manager to be redirect.</param>
 551     virtual public void SetupOnFirstTouch(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry) {
 552                                                          Efl.Ui.Focus.IManagerConcrete.NativeMethods.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);
 553         Eina.Error.RaiseIfUnhandledException();
 554                                          }
 555     /// <summary>This disables the cache invalidation when an object is moved.
 556     /// 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.
 557     /// (Since EFL 1.22)</summary>
 558     virtual public void FreezeDirtyLogic() {
 559          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 560         Eina.Error.RaiseIfUnhandledException();
 561          }
 562     /// <summary>This enables the cache invalidation when an object is moved.
 563     /// This is the counterpart to <see cref="Efl.Ui.Focus.IManager.FreezeDirtyLogic"/>.
 564     /// (Since EFL 1.22)</summary>
 565     virtual public void DirtyLogicUnfreeze() {
 566          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 567         Eina.Error.RaiseIfUnhandledException();
 568          }
 569     /// <summary>The element which is currently focused by this manager
 570     /// 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.
 571     /// (Since EFL 1.22)</summary>
 572     /// <value>Currently focused element.</value>
 573     public Efl.Ui.Focus.IObject ManagerFocus {
 574         get { return GetManagerFocus(); }
 575         set { SetManagerFocus(value); }
 576     }
 577     /// <summary>Add another manager to serve the move requests.
 578     /// 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.
 579     /// (Since EFL 1.22)</summary>
 580     /// <value>The redirect manager.</value>
 581     public Efl.Ui.Focus.IManager Redirect {
 582         get { return GetRedirect(); }
 583         set { SetRedirect(value); }
 584     }
 585     /// <summary>The list of elements which are at the border of the graph.
 586     /// 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"/>
 587     /// (Since EFL 1.22)</summary>
 588     /// <value>An iterator over the border objects.</value>
 589     public Eina.Iterator<Efl.Ui.Focus.IObject> BorderElements {
 590         get { return GetBorderElements(); }
 591     }
 592     /// <summary>Root node for all logical subtrees.
 593     /// This property can only be set once.
 594     /// (Since EFL 1.22)</summary>
 595     /// <value>Will be registered into this manager object.</value>
 596     public Efl.Ui.Focus.IObject Root {
 597         get { return GetRoot(); }
 598         set { SetRoot(value); }
 599     }
 600     private static IntPtr GetEflClassStatic()
 601     {
 602         return Efl.Ui.Focus.ManagerCalc.efl_ui_focus_manager_calc_class_get();
 603     }
 604     /// <summary>Wrapper for native methods and virtual method delegates.
 605     /// For internal use by generated code only.</summary>
 606     public new class NativeMethods : Efl.Object.NativeMethods
 607     {
 608         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 609         /// <summary>Gets the list of Eo operations to override.</summary>
 610         /// <returns>The list of Eo operations to be overload.</returns>
 611         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 612         {
 613             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 614             var methods = Efl.Eo.Globals.GetUserMethods(type);
 615
 616             if (efl_ui_focus_manager_calc_register_static_delegate == null)
 617             {
 618                 efl_ui_focus_manager_calc_register_static_delegate = new efl_ui_focus_manager_calc_register_delegate(register);
 619             }
 620
 621             if (methods.FirstOrDefault(m => m.Name == "Register") != null)
 622             {
 623                 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) });
 624             }
 625
 626             if (efl_ui_focus_manager_calc_register_logical_static_delegate == null)
 627             {
 628                 efl_ui_focus_manager_calc_register_logical_static_delegate = new efl_ui_focus_manager_calc_register_logical_delegate(register_logical);
 629             }
 630
 631             if (methods.FirstOrDefault(m => m.Name == "RegisterLogical") != null)
 632             {
 633                 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) });
 634             }
 635
 636             if (efl_ui_focus_manager_calc_update_redirect_static_delegate == null)
 637             {
 638                 efl_ui_focus_manager_calc_update_redirect_static_delegate = new efl_ui_focus_manager_calc_update_redirect_delegate(update_redirect);
 639             }
 640
 641             if (methods.FirstOrDefault(m => m.Name == "UpdateRedirect") != null)
 642             {
 643                 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) });
 644             }
 645
 646             if (efl_ui_focus_manager_calc_update_parent_static_delegate == null)
 647             {
 648                 efl_ui_focus_manager_calc_update_parent_static_delegate = new efl_ui_focus_manager_calc_update_parent_delegate(update_parent);
 649             }
 650
 651             if (methods.FirstOrDefault(m => m.Name == "UpdateParent") != null)
 652             {
 653                 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) });
 654             }
 655
 656             if (efl_ui_focus_manager_calc_update_children_static_delegate == null)
 657             {
 658                 efl_ui_focus_manager_calc_update_children_static_delegate = new efl_ui_focus_manager_calc_update_children_delegate(update_children);
 659             }
 660
 661             if (methods.FirstOrDefault(m => m.Name == "UpdateChildren") != null)
 662             {
 663                 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) });
 664             }
 665
 666             if (efl_ui_focus_manager_calc_update_order_static_delegate == null)
 667             {
 668                 efl_ui_focus_manager_calc_update_order_static_delegate = new efl_ui_focus_manager_calc_update_order_delegate(update_order);
 669             }
 670
 671             if (methods.FirstOrDefault(m => m.Name == "UpdateOrder") != null)
 672             {
 673                 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) });
 674             }
 675
 676             if (efl_ui_focus_manager_calc_unregister_static_delegate == null)
 677             {
 678                 efl_ui_focus_manager_calc_unregister_static_delegate = new efl_ui_focus_manager_calc_unregister_delegate(unregister);
 679             }
 680
 681             if (methods.FirstOrDefault(m => m.Name == "Unregister") != null)
 682             {
 683                 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) });
 684             }
 685
 686             if (efl_ui_focus_manager_focus_get_static_delegate == null)
 687             {
 688                 efl_ui_focus_manager_focus_get_static_delegate = new efl_ui_focus_manager_focus_get_delegate(manager_focus_get);
 689             }
 690
 691             if (methods.FirstOrDefault(m => m.Name == "GetManagerFocus") != null)
 692             {
 693                 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) });
 694             }
 695
 696             if (efl_ui_focus_manager_focus_set_static_delegate == null)
 697             {
 698                 efl_ui_focus_manager_focus_set_static_delegate = new efl_ui_focus_manager_focus_set_delegate(manager_focus_set);
 699             }
 700
 701             if (methods.FirstOrDefault(m => m.Name == "SetManagerFocus") != null)
 702             {
 703                 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) });
 704             }
 705
 706             if (efl_ui_focus_manager_redirect_get_static_delegate == null)
 707             {
 708                 efl_ui_focus_manager_redirect_get_static_delegate = new efl_ui_focus_manager_redirect_get_delegate(redirect_get);
 709             }
 710
 711             if (methods.FirstOrDefault(m => m.Name == "GetRedirect") != null)
 712             {
 713                 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) });
 714             }
 715
 716             if (efl_ui_focus_manager_redirect_set_static_delegate == null)
 717             {
 718                 efl_ui_focus_manager_redirect_set_static_delegate = new efl_ui_focus_manager_redirect_set_delegate(redirect_set);
 719             }
 720
 721             if (methods.FirstOrDefault(m => m.Name == "SetRedirect") != null)
 722             {
 723                 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) });
 724             }
 725
 726             if (efl_ui_focus_manager_border_elements_get_static_delegate == null)
 727             {
 728                 efl_ui_focus_manager_border_elements_get_static_delegate = new efl_ui_focus_manager_border_elements_get_delegate(border_elements_get);
 729             }
 730
 731             if (methods.FirstOrDefault(m => m.Name == "GetBorderElements") != null)
 732             {
 733                 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) });
 734             }
 735
 736             if (efl_ui_focus_manager_viewport_elements_get_static_delegate == null)
 737             {
 738                 efl_ui_focus_manager_viewport_elements_get_static_delegate = new efl_ui_focus_manager_viewport_elements_get_delegate(viewport_elements_get);
 739             }
 740
 741             if (methods.FirstOrDefault(m => m.Name == "GetViewportElements") != null)
 742             {
 743                 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) });
 744             }
 745
 746             if (efl_ui_focus_manager_root_get_static_delegate == null)
 747             {
 748                 efl_ui_focus_manager_root_get_static_delegate = new efl_ui_focus_manager_root_get_delegate(root_get);
 749             }
 750
 751             if (methods.FirstOrDefault(m => m.Name == "GetRoot") != null)
 752             {
 753                 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) });
 754             }
 755
 756             if (efl_ui_focus_manager_root_set_static_delegate == null)
 757             {
 758                 efl_ui_focus_manager_root_set_static_delegate = new efl_ui_focus_manager_root_set_delegate(root_set);
 759             }
 760
 761             if (methods.FirstOrDefault(m => m.Name == "SetRoot") != null)
 762             {
 763                 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) });
 764             }
 765
 766             if (efl_ui_focus_manager_move_static_delegate == null)
 767             {
 768                 efl_ui_focus_manager_move_static_delegate = new efl_ui_focus_manager_move_delegate(move);
 769             }
 770
 771             if (methods.FirstOrDefault(m => m.Name == "Move") != null)
 772             {
 773                 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) });
 774             }
 775
 776             if (efl_ui_focus_manager_request_move_static_delegate == null)
 777             {
 778                 efl_ui_focus_manager_request_move_static_delegate = new efl_ui_focus_manager_request_move_delegate(request_move);
 779             }
 780
 781             if (methods.FirstOrDefault(m => m.Name == "MoveRequest") != null)
 782             {
 783                 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) });
 784             }
 785
 786             if (efl_ui_focus_manager_request_subchild_static_delegate == null)
 787             {
 788                 efl_ui_focus_manager_request_subchild_static_delegate = new efl_ui_focus_manager_request_subchild_delegate(request_subchild);
 789             }
 790
 791             if (methods.FirstOrDefault(m => m.Name == "RequestSubchild") != null)
 792             {
 793                 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) });
 794             }
 795
 796             if (efl_ui_focus_manager_fetch_static_delegate == null)
 797             {
 798                 efl_ui_focus_manager_fetch_static_delegate = new efl_ui_focus_manager_fetch_delegate(fetch);
 799             }
 800
 801             if (methods.FirstOrDefault(m => m.Name == "Fetch") != null)
 802             {
 803                 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) });
 804             }
 805
 806             if (efl_ui_focus_manager_logical_end_static_delegate == null)
 807             {
 808                 efl_ui_focus_manager_logical_end_static_delegate = new efl_ui_focus_manager_logical_end_delegate(logical_end);
 809             }
 810
 811             if (methods.FirstOrDefault(m => m.Name == "LogicalEnd") != null)
 812             {
 813                 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) });
 814             }
 815
 816             if (efl_ui_focus_manager_reset_history_static_delegate == null)
 817             {
 818                 efl_ui_focus_manager_reset_history_static_delegate = new efl_ui_focus_manager_reset_history_delegate(reset_history);
 819             }
 820
 821             if (methods.FirstOrDefault(m => m.Name == "ResetHistory") != null)
 822             {
 823                 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) });
 824             }
 825
 826             if (efl_ui_focus_manager_pop_history_stack_static_delegate == null)
 827             {
 828                 efl_ui_focus_manager_pop_history_stack_static_delegate = new efl_ui_focus_manager_pop_history_stack_delegate(pop_history_stack);
 829             }
 830
 831             if (methods.FirstOrDefault(m => m.Name == "PopHistoryStack") != null)
 832             {
 833                 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) });
 834             }
 835
 836             if (efl_ui_focus_manager_setup_on_first_touch_static_delegate == null)
 837             {
 838                 efl_ui_focus_manager_setup_on_first_touch_static_delegate = new efl_ui_focus_manager_setup_on_first_touch_delegate(setup_on_first_touch);
 839             }
 840
 841             if (methods.FirstOrDefault(m => m.Name == "SetupOnFirstTouch") != null)
 842             {
 843                 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) });
 844             }
 845
 846             if (efl_ui_focus_manager_dirty_logic_freeze_static_delegate == null)
 847             {
 848                 efl_ui_focus_manager_dirty_logic_freeze_static_delegate = new efl_ui_focus_manager_dirty_logic_freeze_delegate(dirty_logic_freeze);
 849             }
 850
 851             if (methods.FirstOrDefault(m => m.Name == "FreezeDirtyLogic") != null)
 852             {
 853                 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) });
 854             }
 855
 856             if (efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate == null)
 857             {
 858                 efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate = new efl_ui_focus_manager_dirty_logic_unfreeze_delegate(dirty_logic_unfreeze);
 859             }
 860
 861             if (methods.FirstOrDefault(m => m.Name == "DirtyLogicUnfreeze") != null)
 862             {
 863                 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) });
 864             }
 865
 866             descs.AddRange(base.GetEoOps(type));
 867             return descs;
 868         }
 869         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 870         /// <returns>The native class pointer.</returns>
 871         public override IntPtr GetEflClass()
 872         {
 873             return Efl.Ui.Focus.ManagerCalc.efl_ui_focus_manager_calc_class_get();
 874         }
 875
 876         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 877
 878         [return: MarshalAs(UnmanagedType.U1)]
 879         private delegate bool efl_ui_focus_manager_calc_register_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 880
 881         [return: MarshalAs(UnmanagedType.U1)]
 882         public delegate bool efl_ui_focus_manager_calc_register_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 883
 884         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");
 885
 886         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)
 887         {
 888             Eina.Log.Debug("function efl_ui_focus_manager_calc_register was called");
 889             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 890             if (ws != null)
 891             {
 892                                                                                     bool _ret_var = default(bool);
 893                 try
 894                 {
 895                     _ret_var = ((ManagerCalc)ws.Target).Register(child, parent, redirect);
 896                 }
 897                 catch (Exception e)
 898                 {
 899                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 900                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 901                 }
 902
 903                                                         return _ret_var;
 904
 905             }
 906             else
 907             {
 908                 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);
 909             }
 910         }
 911
 912         private static efl_ui_focus_manager_calc_register_delegate efl_ui_focus_manager_calc_register_static_delegate;
 913
 914         [return: MarshalAs(UnmanagedType.U1)]
 915         private delegate bool efl_ui_focus_manager_calc_register_logical_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 916
 917         [return: MarshalAs(UnmanagedType.U1)]
 918         public delegate bool efl_ui_focus_manager_calc_register_logical_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 919
 920         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");
 921
 922         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)
 923         {
 924             Eina.Log.Debug("function efl_ui_focus_manager_calc_register_logical was called");
 925             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 926             if (ws != null)
 927             {
 928                                                                                     bool _ret_var = default(bool);
 929                 try
 930                 {
 931                     _ret_var = ((ManagerCalc)ws.Target).RegisterLogical(child, parent, redirect);
 932                 }
 933                 catch (Exception e)
 934                 {
 935                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 936                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 937                 }
 938
 939                                                         return _ret_var;
 940
 941             }
 942             else
 943             {
 944                 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);
 945             }
 946         }
 947
 948         private static efl_ui_focus_manager_calc_register_logical_delegate efl_ui_focus_manager_calc_register_logical_static_delegate;
 949
 950         [return: MarshalAs(UnmanagedType.U1)]
 951         private delegate bool efl_ui_focus_manager_calc_update_redirect_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 952
 953         [return: MarshalAs(UnmanagedType.U1)]
 954         public delegate bool efl_ui_focus_manager_calc_update_redirect_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
 955
 956         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");
 957
 958         private static bool update_redirect(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IManager redirect)
 959         {
 960             Eina.Log.Debug("function efl_ui_focus_manager_calc_update_redirect was called");
 961             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 962             if (ws != null)
 963             {
 964                                                             bool _ret_var = default(bool);
 965                 try
 966                 {
 967                     _ret_var = ((ManagerCalc)ws.Target).UpdateRedirect(child, redirect);
 968                 }
 969                 catch (Exception e)
 970                 {
 971                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 972                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 973                 }
 974
 975                                         return _ret_var;
 976
 977             }
 978             else
 979             {
 980                 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);
 981             }
 982         }
 983
 984         private static efl_ui_focus_manager_calc_update_redirect_delegate efl_ui_focus_manager_calc_update_redirect_static_delegate;
 985
 986         [return: MarshalAs(UnmanagedType.U1)]
 987         private delegate bool efl_ui_focus_manager_calc_update_parent_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent);
 988
 989         [return: MarshalAs(UnmanagedType.U1)]
 990         public delegate bool efl_ui_focus_manager_calc_update_parent_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent);
 991
 992         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");
 993
 994         private static bool update_parent(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child, Efl.Ui.Focus.IObject parent)
 995         {
 996             Eina.Log.Debug("function efl_ui_focus_manager_calc_update_parent was called");
 997             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 998             if (ws != null)
 999             {
1000                                                             bool _ret_var = default(bool);
1001                 try
1002                 {
1003                     _ret_var = ((ManagerCalc)ws.Target).UpdateParent(child, parent);
1004                 }
1005                 catch (Exception e)
1006                 {
1007                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1008                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1009                 }
1010
1011                                         return _ret_var;
1012
1013             }
1014             else
1015             {
1016                 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);
1017             }
1018         }
1019
1020         private static efl_ui_focus_manager_calc_update_parent_delegate efl_ui_focus_manager_calc_update_parent_static_delegate;
1021
1022         [return: MarshalAs(UnmanagedType.U1)]
1023         private delegate bool efl_ui_focus_manager_calc_update_children_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent,  System.IntPtr children);
1024
1025         [return: MarshalAs(UnmanagedType.U1)]
1026         public delegate bool efl_ui_focus_manager_calc_update_children_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent,  System.IntPtr children);
1027
1028         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");
1029
1030         private static bool update_children(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject parent, System.IntPtr children)
1031         {
1032             Eina.Log.Debug("function efl_ui_focus_manager_calc_update_children was called");
1033             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1034             if (ws != null)
1035             {
1036                 var _in_children = new Eina.List<Efl.Ui.Focus.IObject>(children, true, false);
1037                                             bool _ret_var = default(bool);
1038                 try
1039                 {
1040                     _ret_var = ((ManagerCalc)ws.Target).UpdateChildren(parent, _in_children);
1041                 }
1042                 catch (Exception e)
1043                 {
1044                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1045                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1046                 }
1047
1048                                         return _ret_var;
1049
1050             }
1051             else
1052             {
1053                 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);
1054             }
1055         }
1056
1057         private static efl_ui_focus_manager_calc_update_children_delegate efl_ui_focus_manager_calc_update_children_static_delegate;
1058
1059
1060         private delegate void efl_ui_focus_manager_calc_update_order_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent,  System.IntPtr children);
1061
1062
1063         public delegate void efl_ui_focus_manager_calc_update_order_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject parent,  System.IntPtr children);
1064
1065         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");
1066
1067         private static void update_order(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject parent, System.IntPtr children)
1068         {
1069             Eina.Log.Debug("function efl_ui_focus_manager_calc_update_order was called");
1070             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1071             if (ws != null)
1072             {
1073                 var _in_children = new Eina.List<Efl.Ui.Focus.IObject>(children, true, false);
1074
1075                 try
1076                 {
1077                     ((ManagerCalc)ws.Target).UpdateOrder(parent, _in_children);
1078                 }
1079                 catch (Exception e)
1080                 {
1081                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1082                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1083                 }
1084
1085
1086             }
1087             else
1088             {
1089                 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);
1090             }
1091         }
1092
1093         private static efl_ui_focus_manager_calc_update_order_delegate efl_ui_focus_manager_calc_update_order_static_delegate;
1094
1095
1096         private delegate void efl_ui_focus_manager_calc_unregister_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
1097
1098
1099         public delegate void efl_ui_focus_manager_calc_unregister_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
1100
1101         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");
1102
1103         private static void unregister(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child)
1104         {
1105             Eina.Log.Debug("function efl_ui_focus_manager_calc_unregister was called");
1106             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1107             if (ws != null)
1108             {
1109
1110                 try
1111                 {
1112                     ((ManagerCalc)ws.Target).Unregister(child);
1113                 }
1114                 catch (Exception e)
1115                 {
1116                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1117                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1118                 }
1119
1120
1121             }
1122             else
1123             {
1124                 efl_ui_focus_manager_calc_unregister_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
1125             }
1126         }
1127
1128         private static efl_ui_focus_manager_calc_unregister_delegate efl_ui_focus_manager_calc_unregister_static_delegate;
1129
1130         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1131         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
1132
1133         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1134         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_api_delegate(System.IntPtr obj);
1135
1136         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");
1137
1138         private static Efl.Ui.Focus.IObject manager_focus_get(System.IntPtr obj, System.IntPtr pd)
1139         {
1140             Eina.Log.Debug("function efl_ui_focus_manager_focus_get was called");
1141             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1142             if (ws != null)
1143             {
1144             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1145                 try
1146                 {
1147                     _ret_var = ((ManagerCalc)ws.Target).GetManagerFocus();
1148                 }
1149                 catch (Exception e)
1150                 {
1151                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1152                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1153                 }
1154
1155         return _ret_var;
1156
1157             }
1158             else
1159             {
1160                 return efl_ui_focus_manager_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1161             }
1162         }
1163
1164         private static efl_ui_focus_manager_focus_get_delegate efl_ui_focus_manager_focus_get_static_delegate;
1165
1166
1167         private delegate void efl_ui_focus_manager_focus_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject focus);
1168
1169
1170         public delegate void efl_ui_focus_manager_focus_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject focus);
1171
1172         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");
1173
1174         private static void manager_focus_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject focus)
1175         {
1176             Eina.Log.Debug("function efl_ui_focus_manager_focus_set was called");
1177             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1178             if (ws != null)
1179             {
1180
1181                 try
1182                 {
1183                     ((ManagerCalc)ws.Target).SetManagerFocus(focus);
1184                 }
1185                 catch (Exception e)
1186                 {
1187                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1188                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1189                 }
1190
1191
1192             }
1193             else
1194             {
1195                 efl_ui_focus_manager_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), focus);
1196             }
1197         }
1198
1199         private static efl_ui_focus_manager_focus_set_delegate efl_ui_focus_manager_focus_set_static_delegate;
1200
1201         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1202         private delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_delegate(System.IntPtr obj, System.IntPtr pd);
1203
1204         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1205         public delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_api_delegate(System.IntPtr obj);
1206
1207         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");
1208
1209         private static Efl.Ui.Focus.IManager redirect_get(System.IntPtr obj, System.IntPtr pd)
1210         {
1211             Eina.Log.Debug("function efl_ui_focus_manager_redirect_get was called");
1212             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1213             if (ws != null)
1214             {
1215             Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
1216                 try
1217                 {
1218                     _ret_var = ((ManagerCalc)ws.Target).GetRedirect();
1219                 }
1220                 catch (Exception e)
1221                 {
1222                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1223                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1224                 }
1225
1226         return _ret_var;
1227
1228             }
1229             else
1230             {
1231                 return efl_ui_focus_manager_redirect_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1232             }
1233         }
1234
1235         private static efl_ui_focus_manager_redirect_get_delegate efl_ui_focus_manager_redirect_get_static_delegate;
1236
1237
1238         private delegate void efl_ui_focus_manager_redirect_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
1239
1240
1241         public delegate void efl_ui_focus_manager_redirect_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
1242
1243         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");
1244
1245         private static void redirect_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IManager redirect)
1246         {
1247             Eina.Log.Debug("function efl_ui_focus_manager_redirect_set was called");
1248             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1249             if (ws != null)
1250             {
1251
1252                 try
1253                 {
1254                     ((ManagerCalc)ws.Target).SetRedirect(redirect);
1255                 }
1256                 catch (Exception e)
1257                 {
1258                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1259                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1260                 }
1261
1262
1263             }
1264             else
1265             {
1266                 efl_ui_focus_manager_redirect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), redirect);
1267             }
1268         }
1269
1270         private static efl_ui_focus_manager_redirect_set_delegate efl_ui_focus_manager_redirect_set_static_delegate;
1271
1272
1273         private delegate System.IntPtr efl_ui_focus_manager_border_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
1274
1275
1276         public delegate System.IntPtr efl_ui_focus_manager_border_elements_get_api_delegate(System.IntPtr obj);
1277
1278         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");
1279
1280         private static System.IntPtr border_elements_get(System.IntPtr obj, System.IntPtr pd)
1281         {
1282             Eina.Log.Debug("function efl_ui_focus_manager_border_elements_get was called");
1283             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1284             if (ws != null)
1285             {
1286             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
1287                 try
1288                 {
1289                     _ret_var = ((ManagerCalc)ws.Target).GetBorderElements();
1290                 }
1291                 catch (Exception e)
1292                 {
1293                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1294                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1295                 }
1296
1297         return _ret_var.Handle;
1298
1299             }
1300             else
1301             {
1302                 return efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1303             }
1304         }
1305
1306         private static efl_ui_focus_manager_border_elements_get_delegate efl_ui_focus_manager_border_elements_get_static_delegate;
1307
1308
1309         private delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct viewport);
1310
1311
1312         public delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct viewport);
1313
1314         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");
1315
1316         private static System.IntPtr viewport_elements_get(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct viewport)
1317         {
1318             Eina.Log.Debug("function efl_ui_focus_manager_viewport_elements_get was called");
1319             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1320             if (ws != null)
1321             {
1322         Eina.Rect _in_viewport = viewport;
1323                             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
1324                 try
1325                 {
1326                     _ret_var = ((ManagerCalc)ws.Target).GetViewportElements(_in_viewport);
1327                 }
1328                 catch (Exception e)
1329                 {
1330                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1331                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1332                 }
1333
1334                         return _ret_var.Handle;
1335
1336             }
1337             else
1338             {
1339                 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);
1340             }
1341         }
1342
1343         private static efl_ui_focus_manager_viewport_elements_get_delegate efl_ui_focus_manager_viewport_elements_get_static_delegate;
1344
1345         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1346         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_delegate(System.IntPtr obj, System.IntPtr pd);
1347
1348         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1349         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_api_delegate(System.IntPtr obj);
1350
1351         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");
1352
1353         private static Efl.Ui.Focus.IObject root_get(System.IntPtr obj, System.IntPtr pd)
1354         {
1355             Eina.Log.Debug("function efl_ui_focus_manager_root_get was called");
1356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1357             if (ws != null)
1358             {
1359             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1360                 try
1361                 {
1362                     _ret_var = ((ManagerCalc)ws.Target).GetRoot();
1363                 }
1364                 catch (Exception e)
1365                 {
1366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1368                 }
1369
1370         return _ret_var;
1371
1372             }
1373             else
1374             {
1375                 return efl_ui_focus_manager_root_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1376             }
1377         }
1378
1379         private static efl_ui_focus_manager_root_get_delegate efl_ui_focus_manager_root_get_static_delegate;
1380
1381         [return: MarshalAs(UnmanagedType.U1)]
1382         private delegate bool efl_ui_focus_manager_root_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1383
1384         [return: MarshalAs(UnmanagedType.U1)]
1385         public delegate bool efl_ui_focus_manager_root_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1386
1387         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");
1388
1389         private static bool root_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
1390         {
1391             Eina.Log.Debug("function efl_ui_focus_manager_root_set was called");
1392             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1393             if (ws != null)
1394             {
1395                                     bool _ret_var = default(bool);
1396                 try
1397                 {
1398                     _ret_var = ((ManagerCalc)ws.Target).SetRoot(root);
1399                 }
1400                 catch (Exception e)
1401                 {
1402                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1403                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1404                 }
1405
1406                         return _ret_var;
1407
1408             }
1409             else
1410             {
1411                 return efl_ui_focus_manager_root_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
1412             }
1413         }
1414
1415         private static efl_ui_focus_manager_root_set_delegate efl_ui_focus_manager_root_set_static_delegate;
1416
1417         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1418         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction);
1419
1420         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1421         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_api_delegate(System.IntPtr obj,  Efl.Ui.Focus.Direction direction);
1422
1423         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");
1424
1425         private static Efl.Ui.Focus.IObject move(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction)
1426         {
1427             Eina.Log.Debug("function efl_ui_focus_manager_move was called");
1428             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1429             if (ws != null)
1430             {
1431                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1432                 try
1433                 {
1434                     _ret_var = ((ManagerCalc)ws.Target).Move(direction);
1435                 }
1436                 catch (Exception e)
1437                 {
1438                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1439                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1440                 }
1441
1442                         return _ret_var;
1443
1444             }
1445             else
1446             {
1447                 return efl_ui_focus_manager_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), direction);
1448             }
1449         }
1450
1451         private static efl_ui_focus_manager_move_delegate efl_ui_focus_manager_move_static_delegate;
1452
1453         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1454         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.U1)] bool logical);
1455
1456         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1457         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.U1)] bool logical);
1458
1459         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");
1460
1461         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)
1462         {
1463             Eina.Log.Debug("function efl_ui_focus_manager_request_move was called");
1464             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1465             if (ws != null)
1466             {
1467                                                                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1468                 try
1469                 {
1470                     _ret_var = ((ManagerCalc)ws.Target).MoveRequest(direction, child, logical);
1471                 }
1472                 catch (Exception e)
1473                 {
1474                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1475                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1476                 }
1477
1478                                                         return _ret_var;
1479
1480             }
1481             else
1482             {
1483                 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);
1484             }
1485         }
1486
1487         private static efl_ui_focus_manager_request_move_delegate efl_ui_focus_manager_request_move_static_delegate;
1488
1489         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1490         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1491
1492         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1493         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_request_subchild_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1494
1495         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");
1496
1497         private static Efl.Ui.Focus.IObject request_subchild(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
1498         {
1499             Eina.Log.Debug("function efl_ui_focus_manager_request_subchild was called");
1500             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1501             if (ws != null)
1502             {
1503                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1504                 try
1505                 {
1506                     _ret_var = ((ManagerCalc)ws.Target).RequestSubchild(root);
1507                 }
1508                 catch (Exception e)
1509                 {
1510                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1511                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1512                 }
1513
1514                         return _ret_var;
1515
1516             }
1517             else
1518             {
1519                 return efl_ui_focus_manager_request_subchild_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
1520             }
1521         }
1522
1523         private static efl_ui_focus_manager_request_subchild_delegate efl_ui_focus_manager_request_subchild_static_delegate;
1524
1525
1526         private delegate System.IntPtr efl_ui_focus_manager_fetch_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
1527
1528
1529         public delegate System.IntPtr efl_ui_focus_manager_fetch_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
1530
1531         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");
1532
1533         private static System.IntPtr fetch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child)
1534         {
1535             Eina.Log.Debug("function efl_ui_focus_manager_fetch was called");
1536             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1537             if (ws != null)
1538             {
1539                                     Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
1540                 try
1541                 {
1542                     _ret_var = ((ManagerCalc)ws.Target).Fetch(child);
1543                 }
1544                 catch (Exception e)
1545                 {
1546                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1547                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1548                 }
1549
1550                         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
1551
1552             }
1553             else
1554             {
1555                 return efl_ui_focus_manager_fetch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
1556             }
1557         }
1558
1559         private static efl_ui_focus_manager_fetch_delegate efl_ui_focus_manager_fetch_static_delegate;
1560
1561
1562         private delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_delegate(System.IntPtr obj, System.IntPtr pd);
1563
1564
1565         public delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_api_delegate(System.IntPtr obj);
1566
1567         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");
1568
1569         private static Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct logical_end(System.IntPtr obj, System.IntPtr pd)
1570         {
1571             Eina.Log.Debug("function efl_ui_focus_manager_logical_end was called");
1572             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1573             if (ws != null)
1574             {
1575             Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
1576                 try
1577                 {
1578                     _ret_var = ((ManagerCalc)ws.Target).LogicalEnd();
1579                 }
1580                 catch (Exception e)
1581                 {
1582                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1583                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1584                 }
1585
1586         return _ret_var;
1587
1588             }
1589             else
1590             {
1591                 return efl_ui_focus_manager_logical_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1592             }
1593         }
1594
1595         private static efl_ui_focus_manager_logical_end_delegate efl_ui_focus_manager_logical_end_static_delegate;
1596
1597
1598         private delegate void efl_ui_focus_manager_reset_history_delegate(System.IntPtr obj, System.IntPtr pd);
1599
1600
1601         public delegate void efl_ui_focus_manager_reset_history_api_delegate(System.IntPtr obj);
1602
1603         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");
1604
1605         private static void reset_history(System.IntPtr obj, System.IntPtr pd)
1606         {
1607             Eina.Log.Debug("function efl_ui_focus_manager_reset_history was called");
1608             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1609             if (ws != null)
1610             {
1611
1612                 try
1613                 {
1614                     ((ManagerCalc)ws.Target).ResetHistory();
1615                 }
1616                 catch (Exception e)
1617                 {
1618                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1619                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1620                 }
1621
1622
1623             }
1624             else
1625             {
1626                 efl_ui_focus_manager_reset_history_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1627             }
1628         }
1629
1630         private static efl_ui_focus_manager_reset_history_delegate efl_ui_focus_manager_reset_history_static_delegate;
1631
1632
1633         private delegate void efl_ui_focus_manager_pop_history_stack_delegate(System.IntPtr obj, System.IntPtr pd);
1634
1635
1636         public delegate void efl_ui_focus_manager_pop_history_stack_api_delegate(System.IntPtr obj);
1637
1638         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");
1639
1640         private static void pop_history_stack(System.IntPtr obj, System.IntPtr pd)
1641         {
1642             Eina.Log.Debug("function efl_ui_focus_manager_pop_history_stack was called");
1643             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1644             if (ws != null)
1645             {
1646
1647                 try
1648                 {
1649                     ((ManagerCalc)ws.Target).PopHistoryStack();
1650                 }
1651                 catch (Exception e)
1652                 {
1653                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1654                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1655                 }
1656
1657
1658             }
1659             else
1660             {
1661                 efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1662             }
1663         }
1664
1665         private static efl_ui_focus_manager_pop_history_stack_delegate efl_ui_focus_manager_pop_history_stack_static_delegate;
1666
1667
1668         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject entry);
1669
1670
1671         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject entry);
1672
1673         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");
1674
1675         private static void setup_on_first_touch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry)
1676         {
1677             Eina.Log.Debug("function efl_ui_focus_manager_setup_on_first_touch was called");
1678             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1679             if (ws != null)
1680             {
1681
1682                 try
1683                 {
1684                     ((ManagerCalc)ws.Target).SetupOnFirstTouch(direction, entry);
1685                 }
1686                 catch (Exception e)
1687                 {
1688                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1689                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1690                 }
1691
1692
1693             }
1694             else
1695             {
1696                 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);
1697             }
1698         }
1699
1700         private static efl_ui_focus_manager_setup_on_first_touch_delegate efl_ui_focus_manager_setup_on_first_touch_static_delegate;
1701
1702
1703         private delegate void efl_ui_focus_manager_dirty_logic_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
1704
1705
1706         public delegate void efl_ui_focus_manager_dirty_logic_freeze_api_delegate(System.IntPtr obj);
1707
1708         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");
1709
1710         private static void dirty_logic_freeze(System.IntPtr obj, System.IntPtr pd)
1711         {
1712             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_freeze was called");
1713             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1714             if (ws != null)
1715             {
1716
1717                 try
1718                 {
1719                     ((ManagerCalc)ws.Target).FreezeDirtyLogic();
1720                 }
1721                 catch (Exception e)
1722                 {
1723                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1724                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1725                 }
1726
1727
1728             }
1729             else
1730             {
1731                 efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1732             }
1733         }
1734
1735         private static efl_ui_focus_manager_dirty_logic_freeze_delegate efl_ui_focus_manager_dirty_logic_freeze_static_delegate;
1736
1737
1738         private delegate void efl_ui_focus_manager_dirty_logic_unfreeze_delegate(System.IntPtr obj, System.IntPtr pd);
1739
1740
1741         public delegate void efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate(System.IntPtr obj);
1742
1743         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");
1744
1745         private static void dirty_logic_unfreeze(System.IntPtr obj, System.IntPtr pd)
1746         {
1747             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_unfreeze was called");
1748             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1749             if (ws != null)
1750             {
1751
1752                 try
1753                 {
1754                     ((ManagerCalc)ws.Target).DirtyLogicUnfreeze();
1755                 }
1756                 catch (Exception e)
1757                 {
1758                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1759                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1760                 }
1761
1762
1763             }
1764             else
1765             {
1766                 efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1767             }
1768         }
1769
1770         private static efl_ui_focus_manager_dirty_logic_unfreeze_delegate efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate;
1771
1772         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1773
1774 }
1775 }
1776 }
1777
1778 }
1779
1780 }
1781