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