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

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