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

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