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