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