internals/src/EflSharp/EflSharp/efl/efl_ui_widget_focus_manager.eo.cs

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