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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>EFL UI popup class</summary>
  13 [Efl.Ui.Popup.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public class Popup : Efl.Ui.LayoutBase, Efl.IContent, Efl.Ui.IWidgetFocusManager, Efl.Ui.Focus.ILayer, Efl.Ui.Focus.IManager
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Popup))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  34         efl_ui_popup_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Popup"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  38     public Popup(Efl.Object parent
  39             , System.String style = null) : base(efl_ui_popup_class_get(), parent)
  40     {
  41         if (Efl.Eo.Globals.ParamHelperCheck(style))
  42         {
  43             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  44         }
  45
  46         FinishInstantiation();
  47     }
  48
  49     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  50     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  51     protected Popup(ConstructingHandle ch) : base(ch)
  52     {
  53     }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Popup"/> class.
  56     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  57     /// <param name="wh">The native pointer to be wrapped.</param>
  58     protected Popup(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  59     {
  60     }
  61
  62     /// <summary>Initializes a new instance of the <see cref="Popup"/> class.
  63     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  64     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  65     /// <param name="parent">The Efl.Object parent of this instance.</param>
  66     protected Popup(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  67     {
  68     }
  69
  70     /// <summary>This is called whenever the user clicks back wall of popup.</summary>
  71     public event EventHandler BackwallClickedEvt
  72     {
  73         add
  74         {
  75             lock (eflBindingEventLock)
  76             {
  77                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  78                 {
  79                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  80                     if (obj != null)
  81                     {
  82                         EventArgs args = EventArgs.Empty;
  83                         try
  84                         {
  85                             value?.Invoke(obj, args);
  86                         }
  87                         catch (Exception e)
  88                         {
  89                             Eina.Log.Error(e.ToString());
  90                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  91                         }
  92                     }
  93                 };
  94
  95                 string key = "_EFL_UI_POPUP_EVENT_BACKWALL_CLICKED";
  96                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  97             }
  98         }
  99
 100         remove
 101         {
 102             lock (eflBindingEventLock)
 103             {
 104                 string key = "_EFL_UI_POPUP_EVENT_BACKWALL_CLICKED";
 105                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 106             }
 107         }
 108     }
 109     ///<summary>Method to raise event BackwallClickedEvt.</summary>
 110     public void OnBackwallClickedEvt(EventArgs e)
 111     {
 112         var key = "_EFL_UI_POPUP_EVENT_BACKWALL_CLICKED";
 113         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 114         if (desc == IntPtr.Zero)
 115         {
 116             Eina.Log.Error($"Failed to get native event {key}");
 117             return;
 118         }
 119
 120         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 121     }
 122     /// <summary>This is called when popup times out.</summary>
 123     public event EventHandler TimeoutEvt
 124     {
 125         add
 126         {
 127             lock (eflBindingEventLock)
 128             {
 129                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 130                 {
 131                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 132                     if (obj != null)
 133                     {
 134                         EventArgs args = EventArgs.Empty;
 135                         try
 136                         {
 137                             value?.Invoke(obj, args);
 138                         }
 139                         catch (Exception e)
 140                         {
 141                             Eina.Log.Error(e.ToString());
 142                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 143                         }
 144                     }
 145                 };
 146
 147                 string key = "_EFL_UI_POPUP_EVENT_TIMEOUT";
 148                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 149             }
 150         }
 151
 152         remove
 153         {
 154             lock (eflBindingEventLock)
 155             {
 156                 string key = "_EFL_UI_POPUP_EVENT_TIMEOUT";
 157                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 158             }
 159         }
 160     }
 161     ///<summary>Method to raise event TimeoutEvt.</summary>
 162     public void OnTimeoutEvt(EventArgs e)
 163     {
 164         var key = "_EFL_UI_POPUP_EVENT_TIMEOUT";
 165         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 166         if (desc == IntPtr.Zero)
 167         {
 168             Eina.Log.Error($"Failed to get native event {key}");
 169             return;
 170         }
 171
 172         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 173     }
 174     /// <summary>Sent after the content is set or unset using the current content object.
 175     /// (Since EFL 1.22)</summary>
 176     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
 177     {
 178         add
 179         {
 180             lock (eflBindingEventLock)
 181             {
 182                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 183                 {
 184                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 185                     if (obj != null)
 186                     {
 187                         Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 188                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 189                         try
 190                         {
 191                             value?.Invoke(obj, args);
 192                         }
 193                         catch (Exception e)
 194                         {
 195                             Eina.Log.Error(e.ToString());
 196                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 197                         }
 198                     }
 199                 };
 200
 201                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 202                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 203             }
 204         }
 205
 206         remove
 207         {
 208             lock (eflBindingEventLock)
 209             {
 210                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 211                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 212             }
 213         }
 214     }
 215     ///<summary>Method to raise event ContentChangedEvt.</summary>
 216     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 217     {
 218         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 219         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 220         if (desc == IntPtr.Zero)
 221         {
 222             Eina.Log.Error($"Failed to get native event {key}");
 223             return;
 224         }
 225
 226         IntPtr info = e.arg.NativeHandle;
 227         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 228     }
 229     /// <summary>Redirect object has changed, the old manager is passed as an event argument.
 230     /// (Since EFL 1.22)</summary>
 231     public event EventHandler<Efl.Ui.Focus.IManagerRedirectChangedEvt_Args> RedirectChangedEvt
 232     {
 233         add
 234         {
 235             lock (eflBindingEventLock)
 236             {
 237                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 238                 {
 239                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 240                     if (obj != null)
 241                     {
 242                         Efl.Ui.Focus.IManagerRedirectChangedEvt_Args args = new Efl.Ui.Focus.IManagerRedirectChangedEvt_Args();
 243                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IManagerConcrete);
 244                         try
 245                         {
 246                             value?.Invoke(obj, args);
 247                         }
 248                         catch (Exception e)
 249                         {
 250                             Eina.Log.Error(e.ToString());
 251                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 252                         }
 253                     }
 254                 };
 255
 256                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
 257                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 258             }
 259         }
 260
 261         remove
 262         {
 263             lock (eflBindingEventLock)
 264             {
 265                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
 266                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 267             }
 268         }
 269     }
 270     ///<summary>Method to raise event RedirectChangedEvt.</summary>
 271     public void OnRedirectChangedEvt(Efl.Ui.Focus.IManagerRedirectChangedEvt_Args e)
 272     {
 273         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
 274         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 275         if (desc == IntPtr.Zero)
 276         {
 277             Eina.Log.Error($"Failed to get native event {key}");
 278             return;
 279         }
 280
 281         IntPtr info = e.arg.NativeHandle;
 282         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 283     }
 284     /// <summary>After this event, the manager object will calculate relations in the graph. Can be used to add / remove children in a lazy fashion.
 285     /// (Since EFL 1.22)</summary>
 286     public event EventHandler FlushPreEvt
 287     {
 288         add
 289         {
 290             lock (eflBindingEventLock)
 291             {
 292                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 293                 {
 294                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 295                     if (obj != null)
 296                     {
 297                         EventArgs args = EventArgs.Empty;
 298                         try
 299                         {
 300                             value?.Invoke(obj, args);
 301                         }
 302                         catch (Exception e)
 303                         {
 304                             Eina.Log.Error(e.ToString());
 305                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 306                         }
 307                     }
 308                 };
 309
 310                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 311                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 312             }
 313         }
 314
 315         remove
 316         {
 317             lock (eflBindingEventLock)
 318             {
 319                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 320                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 321             }
 322         }
 323     }
 324     ///<summary>Method to raise event FlushPreEvt.</summary>
 325     public void OnFlushPreEvt(EventArgs e)
 326     {
 327         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
 328         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 329         if (desc == IntPtr.Zero)
 330         {
 331             Eina.Log.Error($"Failed to get native event {key}");
 332             return;
 333         }
 334
 335         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 336     }
 337     /// <summary>Cached relationship calculation results have been invalidated.
 338     /// (Since EFL 1.22)</summary>
 339     public event EventHandler CoordsDirtyEvt
 340     {
 341         add
 342         {
 343             lock (eflBindingEventLock)
 344             {
 345                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 346                 {
 347                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 348                     if (obj != null)
 349                     {
 350                         EventArgs args = EventArgs.Empty;
 351                         try
 352                         {
 353                             value?.Invoke(obj, args);
 354                         }
 355                         catch (Exception e)
 356                         {
 357                             Eina.Log.Error(e.ToString());
 358                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 359                         }
 360                     }
 361                 };
 362
 363                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 364                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 365             }
 366         }
 367
 368         remove
 369         {
 370             lock (eflBindingEventLock)
 371             {
 372                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 373                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 374             }
 375         }
 376     }
 377     ///<summary>Method to raise event CoordsDirtyEvt.</summary>
 378     public void OnCoordsDirtyEvt(EventArgs e)
 379     {
 380         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
 381         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 382         if (desc == IntPtr.Zero)
 383         {
 384             Eina.Log.Error($"Failed to get native event {key}");
 385             return;
 386         }
 387
 388         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 389     }
 390     /// <summary>The manager_focus property has changed. The previously focused object is passed as an event argument.
 391     /// (Since EFL 1.22)</summary>
 392     public event EventHandler<Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args> ManagerFocusChangedEvt
 393     {
 394         add
 395         {
 396             lock (eflBindingEventLock)
 397             {
 398                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 399                 {
 400                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 401                     if (obj != null)
 402                     {
 403                         Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args args = new Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args();
 404                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IObjectConcrete);
 405                         try
 406                         {
 407                             value?.Invoke(obj, args);
 408                         }
 409                         catch (Exception e)
 410                         {
 411                             Eina.Log.Error(e.ToString());
 412                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 413                         }
 414                     }
 415                 };
 416
 417                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 418                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 419             }
 420         }
 421
 422         remove
 423         {
 424             lock (eflBindingEventLock)
 425             {
 426                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 427                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 428             }
 429         }
 430     }
 431     ///<summary>Method to raise event ManagerFocusChangedEvt.</summary>
 432     public void OnManagerFocusChangedEvt(Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args e)
 433     {
 434         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
 435         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 436         if (desc == IntPtr.Zero)
 437         {
 438             Eina.Log.Error($"Failed to get native event {key}");
 439             return;
 440         }
 441
 442         IntPtr info = e.arg.NativeHandle;
 443         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 444     }
 445     /// <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.
 446     /// (Since EFL 1.22)</summary>
 447     public event EventHandler<Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args> DirtyLogicFreezeChangedEvt
 448     {
 449         add
 450         {
 451             lock (eflBindingEventLock)
 452             {
 453                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 454                 {
 455                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 456                     if (obj != null)
 457                     {
 458                         Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args args = new Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args();
 459                         args.arg = Marshal.ReadByte(evt.Info) != 0;
 460                         try
 461                         {
 462                             value?.Invoke(obj, args);
 463                         }
 464                         catch (Exception e)
 465                         {
 466                             Eina.Log.Error(e.ToString());
 467                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 468                         }
 469                     }
 470                 };
 471
 472                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 473                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 474             }
 475         }
 476
 477         remove
 478         {
 479             lock (eflBindingEventLock)
 480             {
 481                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 482                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 483             }
 484         }
 485     }
 486     ///<summary>Method to raise event DirtyLogicFreezeChangedEvt.</summary>
 487     public void OnDirtyLogicFreezeChangedEvt(Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args e)
 488     {
 489         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
 490         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 491         if (desc == IntPtr.Zero)
 492         {
 493             Eina.Log.Error($"Failed to get native event {key}");
 494             return;
 495         }
 496
 497         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 498         try
 499         {
 500             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 501         }
 502         finally
 503         {
 504             Marshal.FreeHGlobal(info);
 505         }
 506     }
 507     /// <summary>A backwall behind the popup.</summary>
 508     public Efl.Ui.PopupPartBackwall BackwallPart
 509     {
 510         get
 511         {
 512             return GetPart("backwall") as Efl.Ui.PopupPartBackwall;
 513         }
 514     }
 515     /// <summary>Get the current popup alignment.</summary>
 516     /// <returns>Alignment type</returns>
 517     virtual public Efl.Ui.PopupAlign GetAlign() {
 518          var _ret_var = Efl.Ui.Popup.NativeMethods.efl_ui_popup_align_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 519         Eina.Error.RaiseIfUnhandledException();
 520         return _ret_var;
 521  }
 522     /// <summary>Set the popup alignment.</summary>
 523     /// <param name="type">Alignment type</param>
 524     virtual public void SetAlign(Efl.Ui.PopupAlign type) {
 525                                  Efl.Ui.Popup.NativeMethods.efl_ui_popup_align_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),type);
 526         Eina.Error.RaiseIfUnhandledException();
 527                          }
 528     /// <summary>Get the currently set timeout seconds.</summary>
 529     /// <returns>Timeout in seconds</returns>
 530     virtual public double GetTimeout() {
 531          var _ret_var = Efl.Ui.Popup.NativeMethods.efl_ui_popup_timeout_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 532         Eina.Error.RaiseIfUnhandledException();
 533         return _ret_var;
 534  }
 535     /// <summary>Set the timeout seconds. After timeout seconds, popup will be deleted automatically.</summary>
 536     /// <param name="time">Timeout in seconds</param>
 537     virtual public void SetTimeout(double time) {
 538                                  Efl.Ui.Popup.NativeMethods.efl_ui_popup_timeout_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),time);
 539         Eina.Error.RaiseIfUnhandledException();
 540                          }
 541     /// <summary>get the current popup size.</summary>
 542     virtual public Eina.Size2D GetPopupSize() {
 543          var _ret_var = Efl.Ui.Popup.NativeMethods.efl_ui_popup_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 544         Eina.Error.RaiseIfUnhandledException();
 545         return _ret_var;
 546  }
 547     /// <summary>Set the popup size.</summary>
 548     virtual public void SetPopupSize(Eina.Size2D size) {
 549          Eina.Size2D.NativeStruct _in_size = size;
 550                         Efl.Ui.Popup.NativeMethods.efl_ui_popup_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_size);
 551         Eina.Error.RaiseIfUnhandledException();
 552                          }
 553     /// <summary>Sub-object currently set as this object&apos;s single content.
 554     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 555     /// (Since EFL 1.22)</summary>
 556     /// <returns>The sub-object.</returns>
 557     virtual public Efl.Gfx.IEntity GetContent() {
 558          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 559         Eina.Error.RaiseIfUnhandledException();
 560         return _ret_var;
 561  }
 562     /// <summary>Sub-object currently set as this object&apos;s single content.
 563     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 564     /// (Since EFL 1.22)</summary>
 565     /// <param name="content">The sub-object.</param>
 566     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
 567     virtual public bool SetContent(Efl.Gfx.IEntity content) {
 568                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),content);
 569         Eina.Error.RaiseIfUnhandledException();
 570                         return _ret_var;
 571  }
 572     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
 573     /// (Since EFL 1.22)</summary>
 574     /// <returns>Unswallowed object</returns>
 575     virtual public Efl.Gfx.IEntity UnsetContent() {
 576          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 577         Eina.Error.RaiseIfUnhandledException();
 578         return _ret_var;
 579  }
 580     /// <summary>If the widget needs a focus manager, this function will be called.
 581     /// It can be used and overriden to inject your own manager or set custom options on the focus manager.
 582     /// (Since EFL 1.22)</summary>
 583     /// <param name="root">The logical root object for focus.</param>
 584     /// <returns>The focus manager.</returns>
 585     virtual public Efl.Ui.Focus.IManager FocusManagerCreate(Efl.Ui.Focus.IObject root) {
 586                                  var _ret_var = Efl.Ui.IWidgetFocusManagerConcrete.NativeMethods.efl_ui_widget_focus_manager_create_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),root);
 587         Eina.Error.RaiseIfUnhandledException();
 588                         return _ret_var;
 589  }
 590     /// <summary>Enable property</summary>
 591     /// <returns><c>true</c> to set enable the layer <c>false</c> to disable it</returns>
 592     virtual public bool GetEnable() {
 593          var _ret_var = Efl.Ui.Focus.ILayerConcrete.NativeMethods.efl_ui_focus_layer_enable_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 594         Eina.Error.RaiseIfUnhandledException();
 595         return _ret_var;
 596  }
 597     /// <summary>Enable property</summary>
 598     /// <param name="v"><c>true</c> to set enable the layer <c>false</c> to disable it</param>
 599     virtual public void SetEnable(bool v) {
 600                                  Efl.Ui.Focus.ILayerConcrete.NativeMethods.efl_ui_focus_layer_enable_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),v);
 601         Eina.Error.RaiseIfUnhandledException();
 602                          }
 603     /// <summary>Constructor for setting the behaviour of the layer</summary>
 604     /// <param name="enable_on_visible"><c>true</c> means layer will set itself once the inheriting widget becomes visible, <c>false</c> means the layer isn&apos;t enabled automatically</param>
 605     /// <param name="cycle">If <c>true</c> the focus will cycle in the layer, if <c>false</c></param>
 606     virtual public void GetBehaviour(out bool enable_on_visible, out bool cycle) {
 607                                                          Efl.Ui.Focus.ILayerConcrete.NativeMethods.efl_ui_focus_layer_behaviour_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out enable_on_visible, out cycle);
 608         Eina.Error.RaiseIfUnhandledException();
 609                                          }
 610     /// <summary>Constructor for setting the behaviour of the layer</summary>
 611     /// <param name="enable_on_visible"><c>true</c> means layer will set itself once the inheriting widget becomes visible, <c>false</c> means the layer isn&apos;t enabled automatically</param>
 612     /// <param name="cycle">If <c>true</c> the focus will cycle in the layer, if <c>false</c></param>
 613     virtual public void SetBehaviour(bool enable_on_visible, bool cycle) {
 614                                                          Efl.Ui.Focus.ILayerConcrete.NativeMethods.efl_ui_focus_layer_behaviour_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),enable_on_visible, cycle);
 615         Eina.Error.RaiseIfUnhandledException();
 616                                          }
 617     /// <summary>The element which is currently focused by this manager
 618     /// 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.
 619     /// (Since EFL 1.22)</summary>
 620     /// <returns>Currently focused element.</returns>
 621     virtual public Efl.Ui.Focus.IObject GetManagerFocus() {
 622          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 623         Eina.Error.RaiseIfUnhandledException();
 624         return _ret_var;
 625  }
 626     /// <summary>The element which is currently focused by this manager
 627     /// 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.
 628     /// (Since EFL 1.22)</summary>
 629     /// <param name="focus">Currently focused element.</param>
 630     virtual public void SetManagerFocus(Efl.Ui.Focus.IObject focus) {
 631                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),focus);
 632         Eina.Error.RaiseIfUnhandledException();
 633                          }
 634     /// <summary>Add another manager to serve the move requests.
 635     /// 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.
 636     /// (Since EFL 1.22)</summary>
 637     /// <returns>The redirect manager.</returns>
 638     virtual public Efl.Ui.Focus.IManager GetRedirect() {
 639          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 640         Eina.Error.RaiseIfUnhandledException();
 641         return _ret_var;
 642  }
 643     /// <summary>Add another manager to serve the move requests.
 644     /// 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.
 645     /// (Since EFL 1.22)</summary>
 646     /// <param name="redirect">The redirect manager.</param>
 647     virtual public void SetRedirect(Efl.Ui.Focus.IManager redirect) {
 648                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),redirect);
 649         Eina.Error.RaiseIfUnhandledException();
 650                          }
 651     /// <summary>The list of elements which are at the border of the graph.
 652     /// 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"/>
 653     /// (Since EFL 1.22)</summary>
 654     /// <returns>An iterator over the border objects.</returns>
 655     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetBorderElements() {
 656          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 657         Eina.Error.RaiseIfUnhandledException();
 658         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false);
 659  }
 660     /// <summary>Get all elements that are at the border of the viewport
 661     /// Every element returned by this is located inside the viewport rectangle, but has a right, left, down or up neighbor outside the viewport.
 662     /// (Since EFL 1.22)</summary>
 663     /// <param name="viewport">The rectangle defining the viewport.</param>
 664     /// <returns>The list of border objects.</returns>
 665     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetViewportElements(Eina.Rect viewport) {
 666          Eina.Rect.NativeStruct _in_viewport = viewport;
 667                         var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_viewport);
 668         Eina.Error.RaiseIfUnhandledException();
 669                         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false);
 670  }
 671     /// <summary>Root node for all logical subtrees.
 672     /// This property can only be set once.
 673     /// (Since EFL 1.22)</summary>
 674     /// <returns>Will be registered into this manager object.</returns>
 675     virtual public Efl.Ui.Focus.IObject GetRoot() {
 676          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 677         Eina.Error.RaiseIfUnhandledException();
 678         return _ret_var;
 679  }
 680     /// <summary>Root node for all logical subtrees.
 681     /// This property can only be set once.
 682     /// (Since EFL 1.22)</summary>
 683     /// <param name="root">Will be registered into this manager object.</param>
 684     /// <returns>If <c>true</c>, this is the root node</returns>
 685     virtual public bool SetRoot(Efl.Ui.Focus.IObject root) {
 686                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),root);
 687         Eina.Error.RaiseIfUnhandledException();
 688                         return _ret_var;
 689  }
 690     /// <summary>Move the focus in the given direction.
 691     /// This call flushes all changes. This means all changes between the last flush and now are computed.
 692     /// (Since EFL 1.22)</summary>
 693     /// <param name="direction">The direction to move to.</param>
 694     /// <returns>The element which is now focused.</returns>
 695     virtual public Efl.Ui.Focus.IObject Move(Efl.Ui.Focus.Direction direction) {
 696                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_move_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),direction);
 697         Eina.Error.RaiseIfUnhandledException();
 698                         return _ret_var;
 699  }
 700     /// <summary>Return the object in the <c>direction</c> from <c>child</c>.
 701     /// (Since EFL 1.22)</summary>
 702     /// <param name="direction">Direction to move focus.</param>
 703     /// <param name="child">The child to move from. Pass <c>null</c> to indicate the currently focused child.</param>
 704     /// <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>
 705     /// <returns>Object that would receive focus if moved in the given direction.</returns>
 706     virtual public Efl.Ui.Focus.IObject MoveRequest(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject child, bool logical) {
 707                                                                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_move_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),direction, child, logical);
 708         Eina.Error.RaiseIfUnhandledException();
 709                                                         return _ret_var;
 710  }
 711     /// <summary>Return the widget in the direction next.
 712     /// 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.
 713     /// (Since EFL 1.22)</summary>
 714     /// <param name="root">Parent for returned child.</param>
 715     /// <returns>Child of passed parameter.</returns>
 716     virtual public Efl.Ui.Focus.IObject RequestSubchild(Efl.Ui.Focus.IObject root) {
 717                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_subchild_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),root);
 718         Eina.Error.RaiseIfUnhandledException();
 719                         return _ret_var;
 720  }
 721     /// <summary>This will fetch the data from a registered node.
 722     /// Be aware this function will trigger a computation of all dirty nodes.
 723     /// (Since EFL 1.22)</summary>
 724     /// <param name="child">The child object to inspect.</param>
 725     /// <returns>The list of relations starting from <c>child</c>.</returns>
 726     virtual public Efl.Ui.Focus.Relations Fetch(Efl.Ui.Focus.IObject child) {
 727                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_fetch_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),child);
 728         Eina.Error.RaiseIfUnhandledException();
 729                         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Ui.Focus.Relations>(_ret_var);
 730         Marshal.FreeHGlobal(_ret_var);
 731         return __ret_tmp;
 732  }
 733     /// <summary>Return the last logical object.
 734     /// The returned object is the last object that would be returned if you start at the root and move the direction into next.
 735     /// (Since EFL 1.22)</summary>
 736     /// <returns>Last object.</returns>
 737     virtual public Efl.Ui.Focus.ManagerLogicalEndDetail LogicalEnd() {
 738          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_logical_end_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 739         Eina.Error.RaiseIfUnhandledException();
 740         return _ret_var;
 741  }
 742     /// <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.
 743     /// You should focus another element immediately after calling this, in order to always have a focused object.
 744     /// (Since EFL 1.22)</summary>
 745     virtual public void ResetHistory() {
 746          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_reset_history_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 747         Eina.Error.RaiseIfUnhandledException();
 748          }
 749     /// <summary>Remove the uppermost history element, and focus the previous one.
 750     /// 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.
 751     /// (Since EFL 1.22)</summary>
 752     virtual public void PopHistoryStack() {
 753          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 754         Eina.Error.RaiseIfUnhandledException();
 755          }
 756     /// <summary>Called when this manager is set as redirect.
 757     /// 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.
 758     /// (Since EFL 1.22)</summary>
 759     /// <param name="direction">The direction in which this should be setup.</param>
 760     /// <param name="entry">The object that caused this manager to be redirect.</param>
 761     virtual public void SetupOnFirstTouch(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry) {
 762                                                          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_setup_on_first_touch_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),direction, entry);
 763         Eina.Error.RaiseIfUnhandledException();
 764                                          }
 765     /// <summary>This disables the cache invalidation when an object is moved.
 766     /// 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.
 767     /// (Since EFL 1.22)</summary>
 768     virtual public void FreezeDirtyLogic() {
 769          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 770         Eina.Error.RaiseIfUnhandledException();
 771          }
 772     /// <summary>This enables the cache invalidation when an object is moved.
 773     /// This is the counterpart to <see cref="Efl.Ui.Focus.IManager.FreezeDirtyLogic"/>.
 774     /// (Since EFL 1.22)</summary>
 775     virtual public void DirtyLogicUnfreeze() {
 776          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 777         Eina.Error.RaiseIfUnhandledException();
 778          }
 779     /// <summary>Get the current popup alignment.</summary>
 780     /// <value>Alignment type</value>
 781     public Efl.Ui.PopupAlign Align {
 782         get { return GetAlign(); }
 783         set { SetAlign(value); }
 784     }
 785     /// <summary>Get the currently set timeout seconds.</summary>
 786     /// <value>Timeout in seconds</value>
 787     public double Timeout {
 788         get { return GetTimeout(); }
 789         set { SetTimeout(value); }
 790     }
 791     /// <summary>get the current popup size.</summary>
 792     public Eina.Size2D PopupSize {
 793         get { return GetPopupSize(); }
 794         set { SetPopupSize(value); }
 795     }
 796     /// <summary>Sub-object currently set as this object&apos;s single content.
 797     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 798     /// (Since EFL 1.22)</summary>
 799     /// <value>The sub-object.</value>
 800     public Efl.Gfx.IEntity Content {
 801         get { return GetContent(); }
 802         set { SetContent(value); }
 803     }
 804     /// <summary>Enable property</summary>
 805     /// <value><c>true</c> to set enable the layer <c>false</c> to disable it</value>
 806     public bool Enable {
 807         get { return GetEnable(); }
 808         set { SetEnable(value); }
 809     }
 810     /// <summary>The element which is currently focused by this manager
 811     /// 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.
 812     /// (Since EFL 1.22)</summary>
 813     /// <value>Currently focused element.</value>
 814     public Efl.Ui.Focus.IObject ManagerFocus {
 815         get { return GetManagerFocus(); }
 816         set { SetManagerFocus(value); }
 817     }
 818     /// <summary>Add another manager to serve the move requests.
 819     /// 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.
 820     /// (Since EFL 1.22)</summary>
 821     /// <value>The redirect manager.</value>
 822     public Efl.Ui.Focus.IManager Redirect {
 823         get { return GetRedirect(); }
 824         set { SetRedirect(value); }
 825     }
 826     /// <summary>The list of elements which are at the border of the graph.
 827     /// 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"/>
 828     /// (Since EFL 1.22)</summary>
 829     /// <value>An iterator over the border objects.</value>
 830     public Eina.Iterator<Efl.Ui.Focus.IObject> BorderElements {
 831         get { return GetBorderElements(); }
 832     }
 833     /// <summary>Root node for all logical subtrees.
 834     /// This property can only be set once.
 835     /// (Since EFL 1.22)</summary>
 836     /// <value>Will be registered into this manager object.</value>
 837     public Efl.Ui.Focus.IObject Root {
 838         get { return GetRoot(); }
 839         set { SetRoot(value); }
 840     }
 841     private static IntPtr GetEflClassStatic()
 842     {
 843         return Efl.Ui.Popup.efl_ui_popup_class_get();
 844     }
 845     /// <summary>Wrapper for native methods and virtual method delegates.
 846     /// For internal use by generated code only.</summary>
 847     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 848     {
 849         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 850         /// <summary>Gets the list of Eo operations to override.</summary>
 851         /// <returns>The list of Eo operations to be overload.</returns>
 852         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 853         {
 854             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 855             var methods = Efl.Eo.Globals.GetUserMethods(type);
 856
 857             if (efl_ui_popup_align_get_static_delegate == null)
 858             {
 859                 efl_ui_popup_align_get_static_delegate = new efl_ui_popup_align_get_delegate(align_get);
 860             }
 861
 862             if (methods.FirstOrDefault(m => m.Name == "GetAlign") != null)
 863             {
 864                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_align_get_static_delegate) });
 865             }
 866
 867             if (efl_ui_popup_align_set_static_delegate == null)
 868             {
 869                 efl_ui_popup_align_set_static_delegate = new efl_ui_popup_align_set_delegate(align_set);
 870             }
 871
 872             if (methods.FirstOrDefault(m => m.Name == "SetAlign") != null)
 873             {
 874                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_align_set_static_delegate) });
 875             }
 876
 877             if (efl_ui_popup_timeout_get_static_delegate == null)
 878             {
 879                 efl_ui_popup_timeout_get_static_delegate = new efl_ui_popup_timeout_get_delegate(timeout_get);
 880             }
 881
 882             if (methods.FirstOrDefault(m => m.Name == "GetTimeout") != null)
 883             {
 884                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_timeout_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_timeout_get_static_delegate) });
 885             }
 886
 887             if (efl_ui_popup_timeout_set_static_delegate == null)
 888             {
 889                 efl_ui_popup_timeout_set_static_delegate = new efl_ui_popup_timeout_set_delegate(timeout_set);
 890             }
 891
 892             if (methods.FirstOrDefault(m => m.Name == "SetTimeout") != null)
 893             {
 894                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_timeout_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_timeout_set_static_delegate) });
 895             }
 896
 897             if (efl_ui_popup_size_get_static_delegate == null)
 898             {
 899                 efl_ui_popup_size_get_static_delegate = new efl_ui_popup_size_get_delegate(popup_size_get);
 900             }
 901
 902             if (methods.FirstOrDefault(m => m.Name == "GetPopupSize") != null)
 903             {
 904                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_size_get_static_delegate) });
 905             }
 906
 907             if (efl_ui_popup_size_set_static_delegate == null)
 908             {
 909                 efl_ui_popup_size_set_static_delegate = new efl_ui_popup_size_set_delegate(popup_size_set);
 910             }
 911
 912             if (methods.FirstOrDefault(m => m.Name == "SetPopupSize") != null)
 913             {
 914                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_popup_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_popup_size_set_static_delegate) });
 915             }
 916
 917             if (efl_content_get_static_delegate == null)
 918             {
 919                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 920             }
 921
 922             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 923             {
 924                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
 925             }
 926
 927             if (efl_content_set_static_delegate == null)
 928             {
 929                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 930             }
 931
 932             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 933             {
 934                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
 935             }
 936
 937             if (efl_content_unset_static_delegate == null)
 938             {
 939                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 940             }
 941
 942             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 943             {
 944                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
 945             }
 946
 947             if (efl_ui_widget_focus_manager_create_static_delegate == null)
 948             {
 949                 efl_ui_widget_focus_manager_create_static_delegate = new efl_ui_widget_focus_manager_create_delegate(focus_manager_create);
 950             }
 951
 952             if (methods.FirstOrDefault(m => m.Name == "FocusManagerCreate") != null)
 953             {
 954                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_widget_focus_manager_create"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_manager_create_static_delegate) });
 955             }
 956
 957             if (efl_ui_focus_layer_enable_get_static_delegate == null)
 958             {
 959                 efl_ui_focus_layer_enable_get_static_delegate = new efl_ui_focus_layer_enable_get_delegate(enable_get);
 960             }
 961
 962             if (methods.FirstOrDefault(m => m.Name == "GetEnable") != null)
 963             {
 964                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_layer_enable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_layer_enable_get_static_delegate) });
 965             }
 966
 967             if (efl_ui_focus_layer_enable_set_static_delegate == null)
 968             {
 969                 efl_ui_focus_layer_enable_set_static_delegate = new efl_ui_focus_layer_enable_set_delegate(enable_set);
 970             }
 971
 972             if (methods.FirstOrDefault(m => m.Name == "SetEnable") != null)
 973             {
 974                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_layer_enable_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_layer_enable_set_static_delegate) });
 975             }
 976
 977             if (efl_ui_focus_layer_behaviour_get_static_delegate == null)
 978             {
 979                 efl_ui_focus_layer_behaviour_get_static_delegate = new efl_ui_focus_layer_behaviour_get_delegate(behaviour_get);
 980             }
 981
 982             if (methods.FirstOrDefault(m => m.Name == "GetBehaviour") != null)
 983             {
 984                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_layer_behaviour_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_layer_behaviour_get_static_delegate) });
 985             }
 986
 987             if (efl_ui_focus_layer_behaviour_set_static_delegate == null)
 988             {
 989                 efl_ui_focus_layer_behaviour_set_static_delegate = new efl_ui_focus_layer_behaviour_set_delegate(behaviour_set);
 990             }
 991
 992             if (methods.FirstOrDefault(m => m.Name == "SetBehaviour") != null)
 993             {
 994                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_layer_behaviour_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_layer_behaviour_set_static_delegate) });
 995             }
 996
 997             if (efl_ui_focus_manager_focus_get_static_delegate == null)
 998             {
 999                 efl_ui_focus_manager_focus_get_static_delegate = new efl_ui_focus_manager_focus_get_delegate(manager_focus_get);
1000             }
1001
1002             if (methods.FirstOrDefault(m => m.Name == "GetManagerFocus") != null)
1003             {
1004                 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) });
1005             }
1006
1007             if (efl_ui_focus_manager_focus_set_static_delegate == null)
1008             {
1009                 efl_ui_focus_manager_focus_set_static_delegate = new efl_ui_focus_manager_focus_set_delegate(manager_focus_set);
1010             }
1011
1012             if (methods.FirstOrDefault(m => m.Name == "SetManagerFocus") != null)
1013             {
1014                 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) });
1015             }
1016
1017             if (efl_ui_focus_manager_redirect_get_static_delegate == null)
1018             {
1019                 efl_ui_focus_manager_redirect_get_static_delegate = new efl_ui_focus_manager_redirect_get_delegate(redirect_get);
1020             }
1021
1022             if (methods.FirstOrDefault(m => m.Name == "GetRedirect") != null)
1023             {
1024                 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) });
1025             }
1026
1027             if (efl_ui_focus_manager_redirect_set_static_delegate == null)
1028             {
1029                 efl_ui_focus_manager_redirect_set_static_delegate = new efl_ui_focus_manager_redirect_set_delegate(redirect_set);
1030             }
1031
1032             if (methods.FirstOrDefault(m => m.Name == "SetRedirect") != null)
1033             {
1034                 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) });
1035             }
1036
1037             if (efl_ui_focus_manager_border_elements_get_static_delegate == null)
1038             {
1039                 efl_ui_focus_manager_border_elements_get_static_delegate = new efl_ui_focus_manager_border_elements_get_delegate(border_elements_get);
1040             }
1041
1042             if (methods.FirstOrDefault(m => m.Name == "GetBorderElements") != null)
1043             {
1044                 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) });
1045             }
1046
1047             if (efl_ui_focus_manager_viewport_elements_get_static_delegate == null)
1048             {
1049                 efl_ui_focus_manager_viewport_elements_get_static_delegate = new efl_ui_focus_manager_viewport_elements_get_delegate(viewport_elements_get);
1050             }
1051
1052             if (methods.FirstOrDefault(m => m.Name == "GetViewportElements") != null)
1053             {
1054                 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) });
1055             }
1056
1057             if (efl_ui_focus_manager_root_get_static_delegate == null)
1058             {
1059                 efl_ui_focus_manager_root_get_static_delegate = new efl_ui_focus_manager_root_get_delegate(root_get);
1060             }
1061
1062             if (methods.FirstOrDefault(m => m.Name == "GetRoot") != null)
1063             {
1064                 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) });
1065             }
1066
1067             if (efl_ui_focus_manager_root_set_static_delegate == null)
1068             {
1069                 efl_ui_focus_manager_root_set_static_delegate = new efl_ui_focus_manager_root_set_delegate(root_set);
1070             }
1071
1072             if (methods.FirstOrDefault(m => m.Name == "SetRoot") != null)
1073             {
1074                 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) });
1075             }
1076
1077             if (efl_ui_focus_manager_move_static_delegate == null)
1078             {
1079                 efl_ui_focus_manager_move_static_delegate = new efl_ui_focus_manager_move_delegate(move);
1080             }
1081
1082             if (methods.FirstOrDefault(m => m.Name == "Move") != null)
1083             {
1084                 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) });
1085             }
1086
1087             if (efl_ui_focus_manager_request_move_static_delegate == null)
1088             {
1089                 efl_ui_focus_manager_request_move_static_delegate = new efl_ui_focus_manager_request_move_delegate(request_move);
1090             }
1091
1092             if (methods.FirstOrDefault(m => m.Name == "MoveRequest") != null)
1093             {
1094                 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) });
1095             }
1096
1097             if (efl_ui_focus_manager_request_subchild_static_delegate == null)
1098             {
1099                 efl_ui_focus_manager_request_subchild_static_delegate = new efl_ui_focus_manager_request_subchild_delegate(request_subchild);
1100             }
1101
1102             if (methods.FirstOrDefault(m => m.Name == "RequestSubchild") != null)
1103             {
1104                 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) });
1105             }
1106
1107             if (efl_ui_focus_manager_fetch_static_delegate == null)
1108             {
1109                 efl_ui_focus_manager_fetch_static_delegate = new efl_ui_focus_manager_fetch_delegate(fetch);
1110             }
1111
1112             if (methods.FirstOrDefault(m => m.Name == "Fetch") != null)
1113             {
1114                 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) });
1115             }
1116
1117             if (efl_ui_focus_manager_logical_end_static_delegate == null)
1118             {
1119                 efl_ui_focus_manager_logical_end_static_delegate = new efl_ui_focus_manager_logical_end_delegate(logical_end);
1120             }
1121
1122             if (methods.FirstOrDefault(m => m.Name == "LogicalEnd") != null)
1123             {
1124                 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) });
1125             }
1126
1127             if (efl_ui_focus_manager_reset_history_static_delegate == null)
1128             {
1129                 efl_ui_focus_manager_reset_history_static_delegate = new efl_ui_focus_manager_reset_history_delegate(reset_history);
1130             }
1131
1132             if (methods.FirstOrDefault(m => m.Name == "ResetHistory") != null)
1133             {
1134                 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) });
1135             }
1136
1137             if (efl_ui_focus_manager_pop_history_stack_static_delegate == null)
1138             {
1139                 efl_ui_focus_manager_pop_history_stack_static_delegate = new efl_ui_focus_manager_pop_history_stack_delegate(pop_history_stack);
1140             }
1141
1142             if (methods.FirstOrDefault(m => m.Name == "PopHistoryStack") != null)
1143             {
1144                 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) });
1145             }
1146
1147             if (efl_ui_focus_manager_setup_on_first_touch_static_delegate == null)
1148             {
1149                 efl_ui_focus_manager_setup_on_first_touch_static_delegate = new efl_ui_focus_manager_setup_on_first_touch_delegate(setup_on_first_touch);
1150             }
1151
1152             if (methods.FirstOrDefault(m => m.Name == "SetupOnFirstTouch") != null)
1153             {
1154                 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) });
1155             }
1156
1157             if (efl_ui_focus_manager_dirty_logic_freeze_static_delegate == null)
1158             {
1159                 efl_ui_focus_manager_dirty_logic_freeze_static_delegate = new efl_ui_focus_manager_dirty_logic_freeze_delegate(dirty_logic_freeze);
1160             }
1161
1162             if (methods.FirstOrDefault(m => m.Name == "FreezeDirtyLogic") != null)
1163             {
1164                 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) });
1165             }
1166
1167             if (efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate == null)
1168             {
1169                 efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate = new efl_ui_focus_manager_dirty_logic_unfreeze_delegate(dirty_logic_unfreeze);
1170             }
1171
1172             if (methods.FirstOrDefault(m => m.Name == "DirtyLogicUnfreeze") != null)
1173             {
1174                 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) });
1175             }
1176
1177             descs.AddRange(base.GetEoOps(type));
1178             return descs;
1179         }
1180         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1181         /// <returns>The native class pointer.</returns>
1182         public override IntPtr GetEflClass()
1183         {
1184             return Efl.Ui.Popup.efl_ui_popup_class_get();
1185         }
1186
1187         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1188
1189
1190         private delegate Efl.Ui.PopupAlign efl_ui_popup_align_get_delegate(System.IntPtr obj, System.IntPtr pd);
1191
1192
1193         public delegate Efl.Ui.PopupAlign efl_ui_popup_align_get_api_delegate(System.IntPtr obj);
1194
1195         public static Efl.Eo.FunctionWrapper<efl_ui_popup_align_get_api_delegate> efl_ui_popup_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_align_get_api_delegate>(Module, "efl_ui_popup_align_get");
1196
1197         private static Efl.Ui.PopupAlign align_get(System.IntPtr obj, System.IntPtr pd)
1198         {
1199             Eina.Log.Debug("function efl_ui_popup_align_get was called");
1200             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1201             if (ws != null)
1202             {
1203             Efl.Ui.PopupAlign _ret_var = default(Efl.Ui.PopupAlign);
1204                 try
1205                 {
1206                     _ret_var = ((Popup)ws.Target).GetAlign();
1207                 }
1208                 catch (Exception e)
1209                 {
1210                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1211                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1212                 }
1213
1214         return _ret_var;
1215
1216             }
1217             else
1218             {
1219                 return efl_ui_popup_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1220             }
1221         }
1222
1223         private static efl_ui_popup_align_get_delegate efl_ui_popup_align_get_static_delegate;
1224
1225
1226         private delegate void efl_ui_popup_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.PopupAlign type);
1227
1228
1229         public delegate void efl_ui_popup_align_set_api_delegate(System.IntPtr obj,  Efl.Ui.PopupAlign type);
1230
1231         public static Efl.Eo.FunctionWrapper<efl_ui_popup_align_set_api_delegate> efl_ui_popup_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_align_set_api_delegate>(Module, "efl_ui_popup_align_set");
1232
1233         private static void align_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.PopupAlign type)
1234         {
1235             Eina.Log.Debug("function efl_ui_popup_align_set was called");
1236             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1237             if (ws != null)
1238             {
1239
1240                 try
1241                 {
1242                     ((Popup)ws.Target).SetAlign(type);
1243                 }
1244                 catch (Exception e)
1245                 {
1246                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1247                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1248                 }
1249
1250
1251             }
1252             else
1253             {
1254                 efl_ui_popup_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
1255             }
1256         }
1257
1258         private static efl_ui_popup_align_set_delegate efl_ui_popup_align_set_static_delegate;
1259
1260
1261         private delegate double efl_ui_popup_timeout_get_delegate(System.IntPtr obj, System.IntPtr pd);
1262
1263
1264         public delegate double efl_ui_popup_timeout_get_api_delegate(System.IntPtr obj);
1265
1266         public static Efl.Eo.FunctionWrapper<efl_ui_popup_timeout_get_api_delegate> efl_ui_popup_timeout_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_timeout_get_api_delegate>(Module, "efl_ui_popup_timeout_get");
1267
1268         private static double timeout_get(System.IntPtr obj, System.IntPtr pd)
1269         {
1270             Eina.Log.Debug("function efl_ui_popup_timeout_get was called");
1271             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1272             if (ws != null)
1273             {
1274             double _ret_var = default(double);
1275                 try
1276                 {
1277                     _ret_var = ((Popup)ws.Target).GetTimeout();
1278                 }
1279                 catch (Exception e)
1280                 {
1281                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1282                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1283                 }
1284
1285         return _ret_var;
1286
1287             }
1288             else
1289             {
1290                 return efl_ui_popup_timeout_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1291             }
1292         }
1293
1294         private static efl_ui_popup_timeout_get_delegate efl_ui_popup_timeout_get_static_delegate;
1295
1296
1297         private delegate void efl_ui_popup_timeout_set_delegate(System.IntPtr obj, System.IntPtr pd,  double time);
1298
1299
1300         public delegate void efl_ui_popup_timeout_set_api_delegate(System.IntPtr obj,  double time);
1301
1302         public static Efl.Eo.FunctionWrapper<efl_ui_popup_timeout_set_api_delegate> efl_ui_popup_timeout_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_timeout_set_api_delegate>(Module, "efl_ui_popup_timeout_set");
1303
1304         private static void timeout_set(System.IntPtr obj, System.IntPtr pd, double time)
1305         {
1306             Eina.Log.Debug("function efl_ui_popup_timeout_set was called");
1307             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1308             if (ws != null)
1309             {
1310
1311                 try
1312                 {
1313                     ((Popup)ws.Target).SetTimeout(time);
1314                 }
1315                 catch (Exception e)
1316                 {
1317                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1318                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1319                 }
1320
1321
1322             }
1323             else
1324             {
1325                 efl_ui_popup_timeout_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), time);
1326             }
1327         }
1328
1329         private static efl_ui_popup_timeout_set_delegate efl_ui_popup_timeout_set_static_delegate;
1330
1331
1332         private delegate Eina.Size2D.NativeStruct efl_ui_popup_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1333
1334
1335         public delegate Eina.Size2D.NativeStruct efl_ui_popup_size_get_api_delegate(System.IntPtr obj);
1336
1337         public static Efl.Eo.FunctionWrapper<efl_ui_popup_size_get_api_delegate> efl_ui_popup_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_size_get_api_delegate>(Module, "efl_ui_popup_size_get");
1338
1339         private static Eina.Size2D.NativeStruct popup_size_get(System.IntPtr obj, System.IntPtr pd)
1340         {
1341             Eina.Log.Debug("function efl_ui_popup_size_get was called");
1342             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1343             if (ws != null)
1344             {
1345             Eina.Size2D _ret_var = default(Eina.Size2D);
1346                 try
1347                 {
1348                     _ret_var = ((Popup)ws.Target).GetPopupSize();
1349                 }
1350                 catch (Exception e)
1351                 {
1352                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1353                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1354                 }
1355
1356         return _ret_var;
1357
1358             }
1359             else
1360             {
1361                 return efl_ui_popup_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1362             }
1363         }
1364
1365         private static efl_ui_popup_size_get_delegate efl_ui_popup_size_get_static_delegate;
1366
1367
1368         private delegate void efl_ui_popup_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
1369
1370
1371         public delegate void efl_ui_popup_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
1372
1373         public static Efl.Eo.FunctionWrapper<efl_ui_popup_size_set_api_delegate> efl_ui_popup_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_popup_size_set_api_delegate>(Module, "efl_ui_popup_size_set");
1374
1375         private static void popup_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
1376         {
1377             Eina.Log.Debug("function efl_ui_popup_size_set was called");
1378             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1379             if (ws != null)
1380             {
1381         Eina.Size2D _in_size = size;
1382
1383                 try
1384                 {
1385                     ((Popup)ws.Target).SetPopupSize(_in_size);
1386                 }
1387                 catch (Exception e)
1388                 {
1389                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1390                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1391                 }
1392
1393
1394             }
1395             else
1396             {
1397                 efl_ui_popup_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
1398             }
1399         }
1400
1401         private static efl_ui_popup_size_set_delegate efl_ui_popup_size_set_static_delegate;
1402
1403         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1404         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
1405
1406         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1407         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
1408
1409         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
1410
1411         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
1412         {
1413             Eina.Log.Debug("function efl_content_get was called");
1414             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1415             if (ws != null)
1416             {
1417             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1418                 try
1419                 {
1420                     _ret_var = ((Popup)ws.Target).GetContent();
1421                 }
1422                 catch (Exception e)
1423                 {
1424                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1425                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1426                 }
1427
1428         return _ret_var;
1429
1430             }
1431             else
1432             {
1433                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1434             }
1435         }
1436
1437         private static efl_content_get_delegate efl_content_get_static_delegate;
1438
1439         [return: MarshalAs(UnmanagedType.U1)]
1440         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
1441
1442         [return: MarshalAs(UnmanagedType.U1)]
1443         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
1444
1445         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
1446
1447         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
1448         {
1449             Eina.Log.Debug("function efl_content_set was called");
1450             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1451             if (ws != null)
1452             {
1453                                     bool _ret_var = default(bool);
1454                 try
1455                 {
1456                     _ret_var = ((Popup)ws.Target).SetContent(content);
1457                 }
1458                 catch (Exception e)
1459                 {
1460                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1461                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1462                 }
1463
1464                         return _ret_var;
1465
1466             }
1467             else
1468             {
1469                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
1470             }
1471         }
1472
1473         private static efl_content_set_delegate efl_content_set_static_delegate;
1474
1475         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1476         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
1477
1478         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1479         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
1480
1481         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
1482
1483         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
1484         {
1485             Eina.Log.Debug("function efl_content_unset was called");
1486             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1487             if (ws != null)
1488             {
1489             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1490                 try
1491                 {
1492                     _ret_var = ((Popup)ws.Target).UnsetContent();
1493                 }
1494                 catch (Exception e)
1495                 {
1496                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1497                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1498                 }
1499
1500         return _ret_var;
1501
1502             }
1503             else
1504             {
1505                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1506             }
1507         }
1508
1509         private static efl_content_unset_delegate efl_content_unset_static_delegate;
1510
1511         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1512         private delegate Efl.Ui.Focus.IManager efl_ui_widget_focus_manager_create_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1513
1514         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1515         public delegate Efl.Ui.Focus.IManager efl_ui_widget_focus_manager_create_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
1516
1517         public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_manager_create_api_delegate> efl_ui_widget_focus_manager_create_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_manager_create_api_delegate>(Module, "efl_ui_widget_focus_manager_create");
1518
1519         private static Efl.Ui.Focus.IManager focus_manager_create(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
1520         {
1521             Eina.Log.Debug("function efl_ui_widget_focus_manager_create was called");
1522             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1523             if (ws != null)
1524             {
1525                                     Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
1526                 try
1527                 {
1528                     _ret_var = ((Popup)ws.Target).FocusManagerCreate(root);
1529                 }
1530                 catch (Exception e)
1531                 {
1532                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1533                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1534                 }
1535
1536                         return _ret_var;
1537
1538             }
1539             else
1540             {
1541                 return efl_ui_widget_focus_manager_create_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
1542             }
1543         }
1544
1545         private static efl_ui_widget_focus_manager_create_delegate efl_ui_widget_focus_manager_create_static_delegate;
1546
1547         [return: MarshalAs(UnmanagedType.U1)]
1548         private delegate bool efl_ui_focus_layer_enable_get_delegate(System.IntPtr obj, System.IntPtr pd);
1549
1550         [return: MarshalAs(UnmanagedType.U1)]
1551         public delegate bool efl_ui_focus_layer_enable_get_api_delegate(System.IntPtr obj);
1552
1553         public static Efl.Eo.FunctionWrapper<efl_ui_focus_layer_enable_get_api_delegate> efl_ui_focus_layer_enable_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_layer_enable_get_api_delegate>(Module, "efl_ui_focus_layer_enable_get");
1554
1555         private static bool enable_get(System.IntPtr obj, System.IntPtr pd)
1556         {
1557             Eina.Log.Debug("function efl_ui_focus_layer_enable_get was called");
1558             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1559             if (ws != null)
1560             {
1561             bool _ret_var = default(bool);
1562                 try
1563                 {
1564                     _ret_var = ((Popup)ws.Target).GetEnable();
1565                 }
1566                 catch (Exception e)
1567                 {
1568                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1569                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1570                 }
1571
1572         return _ret_var;
1573
1574             }
1575             else
1576             {
1577                 return efl_ui_focus_layer_enable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1578             }
1579         }
1580
1581         private static efl_ui_focus_layer_enable_get_delegate efl_ui_focus_layer_enable_get_static_delegate;
1582
1583
1584         private delegate void efl_ui_focus_layer_enable_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool v);
1585
1586
1587         public delegate void efl_ui_focus_layer_enable_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool v);
1588
1589         public static Efl.Eo.FunctionWrapper<efl_ui_focus_layer_enable_set_api_delegate> efl_ui_focus_layer_enable_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_layer_enable_set_api_delegate>(Module, "efl_ui_focus_layer_enable_set");
1590
1591         private static void enable_set(System.IntPtr obj, System.IntPtr pd, bool v)
1592         {
1593             Eina.Log.Debug("function efl_ui_focus_layer_enable_set was called");
1594             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1595             if (ws != null)
1596             {
1597
1598                 try
1599                 {
1600                     ((Popup)ws.Target).SetEnable(v);
1601                 }
1602                 catch (Exception e)
1603                 {
1604                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1605                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1606                 }
1607
1608
1609             }
1610             else
1611             {
1612                 efl_ui_focus_layer_enable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), v);
1613             }
1614         }
1615
1616         private static efl_ui_focus_layer_enable_set_delegate efl_ui_focus_layer_enable_set_static_delegate;
1617
1618
1619         private delegate void efl_ui_focus_layer_behaviour_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] out bool enable_on_visible, [MarshalAs(UnmanagedType.U1)] out bool cycle);
1620
1621
1622         public delegate void efl_ui_focus_layer_behaviour_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] out bool enable_on_visible, [MarshalAs(UnmanagedType.U1)] out bool cycle);
1623
1624         public static Efl.Eo.FunctionWrapper<efl_ui_focus_layer_behaviour_get_api_delegate> efl_ui_focus_layer_behaviour_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_layer_behaviour_get_api_delegate>(Module, "efl_ui_focus_layer_behaviour_get");
1625
1626         private static void behaviour_get(System.IntPtr obj, System.IntPtr pd, out bool enable_on_visible, out bool cycle)
1627         {
1628             Eina.Log.Debug("function efl_ui_focus_layer_behaviour_get was called");
1629             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1630             if (ws != null)
1631             {
1632                         enable_on_visible = default(bool);        cycle = default(bool);
1633                 try
1634                 {
1635                     ((Popup)ws.Target).GetBehaviour(out enable_on_visible, out cycle);
1636                 }
1637                 catch (Exception e)
1638                 {
1639                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1640                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1641                 }
1642
1643
1644             }
1645             else
1646             {
1647                 efl_ui_focus_layer_behaviour_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out enable_on_visible, out cycle);
1648             }
1649         }
1650
1651         private static efl_ui_focus_layer_behaviour_get_delegate efl_ui_focus_layer_behaviour_get_static_delegate;
1652
1653
1654         private delegate void efl_ui_focus_layer_behaviour_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable_on_visible, [MarshalAs(UnmanagedType.U1)] bool cycle);
1655
1656
1657         public delegate void efl_ui_focus_layer_behaviour_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable_on_visible, [MarshalAs(UnmanagedType.U1)] bool cycle);
1658
1659         public static Efl.Eo.FunctionWrapper<efl_ui_focus_layer_behaviour_set_api_delegate> efl_ui_focus_layer_behaviour_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_layer_behaviour_set_api_delegate>(Module, "efl_ui_focus_layer_behaviour_set");
1660
1661         private static void behaviour_set(System.IntPtr obj, System.IntPtr pd, bool enable_on_visible, bool cycle)
1662         {
1663             Eina.Log.Debug("function efl_ui_focus_layer_behaviour_set was called");
1664             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1665             if (ws != null)
1666             {
1667
1668                 try
1669                 {
1670                     ((Popup)ws.Target).SetBehaviour(enable_on_visible, cycle);
1671                 }
1672                 catch (Exception e)
1673                 {
1674                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1675                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1676                 }
1677
1678
1679             }
1680             else
1681             {
1682                 efl_ui_focus_layer_behaviour_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enable_on_visible, cycle);
1683             }
1684         }
1685
1686         private static efl_ui_focus_layer_behaviour_set_delegate efl_ui_focus_layer_behaviour_set_static_delegate;
1687
1688         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1689         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
1690
1691         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1692         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_api_delegate(System.IntPtr obj);
1693
1694         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");
1695
1696         private static Efl.Ui.Focus.IObject manager_focus_get(System.IntPtr obj, System.IntPtr pd)
1697         {
1698             Eina.Log.Debug("function efl_ui_focus_manager_focus_get was called");
1699             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1700             if (ws != null)
1701             {
1702             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1703                 try
1704                 {
1705                     _ret_var = ((Popup)ws.Target).GetManagerFocus();
1706                 }
1707                 catch (Exception e)
1708                 {
1709                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1710                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1711                 }
1712
1713         return _ret_var;
1714
1715             }
1716             else
1717             {
1718                 return efl_ui_focus_manager_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1719             }
1720         }
1721
1722         private static efl_ui_focus_manager_focus_get_delegate efl_ui_focus_manager_focus_get_static_delegate;
1723
1724
1725         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);
1726
1727
1728         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);
1729
1730         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");
1731
1732         private static void manager_focus_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject focus)
1733         {
1734             Eina.Log.Debug("function efl_ui_focus_manager_focus_set was called");
1735             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1736             if (ws != null)
1737             {
1738
1739                 try
1740                 {
1741                     ((Popup)ws.Target).SetManagerFocus(focus);
1742                 }
1743                 catch (Exception e)
1744                 {
1745                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1746                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1747                 }
1748
1749
1750             }
1751             else
1752             {
1753                 efl_ui_focus_manager_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), focus);
1754             }
1755         }
1756
1757         private static efl_ui_focus_manager_focus_set_delegate efl_ui_focus_manager_focus_set_static_delegate;
1758
1759         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1760         private delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_delegate(System.IntPtr obj, System.IntPtr pd);
1761
1762         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1763         public delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_api_delegate(System.IntPtr obj);
1764
1765         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");
1766
1767         private static Efl.Ui.Focus.IManager redirect_get(System.IntPtr obj, System.IntPtr pd)
1768         {
1769             Eina.Log.Debug("function efl_ui_focus_manager_redirect_get was called");
1770             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1771             if (ws != null)
1772             {
1773             Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
1774                 try
1775                 {
1776                     _ret_var = ((Popup)ws.Target).GetRedirect();
1777                 }
1778                 catch (Exception e)
1779                 {
1780                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1781                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1782                 }
1783
1784         return _ret_var;
1785
1786             }
1787             else
1788             {
1789                 return efl_ui_focus_manager_redirect_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1790             }
1791         }
1792
1793         private static efl_ui_focus_manager_redirect_get_delegate efl_ui_focus_manager_redirect_get_static_delegate;
1794
1795
1796         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);
1797
1798
1799         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);
1800
1801         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");
1802
1803         private static void redirect_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IManager redirect)
1804         {
1805             Eina.Log.Debug("function efl_ui_focus_manager_redirect_set was called");
1806             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1807             if (ws != null)
1808             {
1809
1810                 try
1811                 {
1812                     ((Popup)ws.Target).SetRedirect(redirect);
1813                 }
1814                 catch (Exception e)
1815                 {
1816                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1817                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1818                 }
1819
1820
1821             }
1822             else
1823             {
1824                 efl_ui_focus_manager_redirect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), redirect);
1825             }
1826         }
1827
1828         private static efl_ui_focus_manager_redirect_set_delegate efl_ui_focus_manager_redirect_set_static_delegate;
1829
1830
1831         private delegate System.IntPtr efl_ui_focus_manager_border_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
1832
1833
1834         public delegate System.IntPtr efl_ui_focus_manager_border_elements_get_api_delegate(System.IntPtr obj);
1835
1836         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");
1837
1838         private static System.IntPtr border_elements_get(System.IntPtr obj, System.IntPtr pd)
1839         {
1840             Eina.Log.Debug("function efl_ui_focus_manager_border_elements_get was called");
1841             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1842             if (ws != null)
1843             {
1844             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
1845                 try
1846                 {
1847                     _ret_var = ((Popup)ws.Target).GetBorderElements();
1848                 }
1849                 catch (Exception e)
1850                 {
1851                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1852                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1853                 }
1854
1855         return _ret_var.Handle;
1856
1857             }
1858             else
1859             {
1860                 return efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1861             }
1862         }
1863
1864         private static efl_ui_focus_manager_border_elements_get_delegate efl_ui_focus_manager_border_elements_get_static_delegate;
1865
1866
1867         private delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct viewport);
1868
1869
1870         public delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct viewport);
1871
1872         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");
1873
1874         private static System.IntPtr viewport_elements_get(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct viewport)
1875         {
1876             Eina.Log.Debug("function efl_ui_focus_manager_viewport_elements_get was called");
1877             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1878             if (ws != null)
1879             {
1880         Eina.Rect _in_viewport = viewport;
1881                             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
1882                 try
1883                 {
1884                     _ret_var = ((Popup)ws.Target).GetViewportElements(_in_viewport);
1885                 }
1886                 catch (Exception e)
1887                 {
1888                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1889                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1890                 }
1891
1892                         return _ret_var.Handle;
1893
1894             }
1895             else
1896             {
1897                 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);
1898             }
1899         }
1900
1901         private static efl_ui_focus_manager_viewport_elements_get_delegate efl_ui_focus_manager_viewport_elements_get_static_delegate;
1902
1903         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1904         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_delegate(System.IntPtr obj, System.IntPtr pd);
1905
1906         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1907         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_api_delegate(System.IntPtr obj);
1908
1909         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");
1910
1911         private static Efl.Ui.Focus.IObject root_get(System.IntPtr obj, System.IntPtr pd)
1912         {
1913             Eina.Log.Debug("function efl_ui_focus_manager_root_get was called");
1914             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1915             if (ws != null)
1916             {
1917             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1918                 try
1919                 {
1920                     _ret_var = ((Popup)ws.Target).GetRoot();
1921                 }
1922                 catch (Exception e)
1923                 {
1924                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1925                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1926                 }
1927
1928         return _ret_var;
1929
1930             }
1931             else
1932             {
1933                 return efl_ui_focus_manager_root_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1934             }
1935         }
1936
1937         private static efl_ui_focus_manager_root_get_delegate efl_ui_focus_manager_root_get_static_delegate;
1938
1939         [return: MarshalAs(UnmanagedType.U1)]
1940         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);
1941
1942         [return: MarshalAs(UnmanagedType.U1)]
1943         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);
1944
1945         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");
1946
1947         private static bool root_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
1948         {
1949             Eina.Log.Debug("function efl_ui_focus_manager_root_set was called");
1950             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1951             if (ws != null)
1952             {
1953                                     bool _ret_var = default(bool);
1954                 try
1955                 {
1956                     _ret_var = ((Popup)ws.Target).SetRoot(root);
1957                 }
1958                 catch (Exception e)
1959                 {
1960                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1961                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1962                 }
1963
1964                         return _ret_var;
1965
1966             }
1967             else
1968             {
1969                 return efl_ui_focus_manager_root_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
1970             }
1971         }
1972
1973         private static efl_ui_focus_manager_root_set_delegate efl_ui_focus_manager_root_set_static_delegate;
1974
1975         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1976         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction);
1977
1978         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1979         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_api_delegate(System.IntPtr obj,  Efl.Ui.Focus.Direction direction);
1980
1981         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");
1982
1983         private static Efl.Ui.Focus.IObject move(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction)
1984         {
1985             Eina.Log.Debug("function efl_ui_focus_manager_move was called");
1986             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1987             if (ws != null)
1988             {
1989                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
1990                 try
1991                 {
1992                     _ret_var = ((Popup)ws.Target).Move(direction);
1993                 }
1994                 catch (Exception e)
1995                 {
1996                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1997                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1998                 }
1999
2000                         return _ret_var;
2001
2002             }
2003             else
2004             {
2005                 return efl_ui_focus_manager_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), direction);
2006             }
2007         }
2008
2009         private static efl_ui_focus_manager_move_delegate efl_ui_focus_manager_move_static_delegate;
2010
2011         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2012         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);
2013
2014         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2015         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);
2016
2017         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");
2018
2019         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)
2020         {
2021             Eina.Log.Debug("function efl_ui_focus_manager_request_move was called");
2022             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2023             if (ws != null)
2024             {
2025                                                                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
2026                 try
2027                 {
2028                     _ret_var = ((Popup)ws.Target).MoveRequest(direction, child, logical);
2029                 }
2030                 catch (Exception e)
2031                 {
2032                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2033                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2034                 }
2035
2036                                                         return _ret_var;
2037
2038             }
2039             else
2040             {
2041                 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);
2042             }
2043         }
2044
2045         private static efl_ui_focus_manager_request_move_delegate efl_ui_focus_manager_request_move_static_delegate;
2046
2047         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2048         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);
2049
2050         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2051         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);
2052
2053         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");
2054
2055         private static Efl.Ui.Focus.IObject request_subchild(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
2056         {
2057             Eina.Log.Debug("function efl_ui_focus_manager_request_subchild was called");
2058             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2059             if (ws != null)
2060             {
2061                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
2062                 try
2063                 {
2064                     _ret_var = ((Popup)ws.Target).RequestSubchild(root);
2065                 }
2066                 catch (Exception e)
2067                 {
2068                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2069                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2070                 }
2071
2072                         return _ret_var;
2073
2074             }
2075             else
2076             {
2077                 return efl_ui_focus_manager_request_subchild_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
2078             }
2079         }
2080
2081         private static efl_ui_focus_manager_request_subchild_delegate efl_ui_focus_manager_request_subchild_static_delegate;
2082
2083
2084         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);
2085
2086
2087         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);
2088
2089         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");
2090
2091         private static System.IntPtr fetch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child)
2092         {
2093             Eina.Log.Debug("function efl_ui_focus_manager_fetch was called");
2094             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2095             if (ws != null)
2096             {
2097                                     Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
2098                 try
2099                 {
2100                     _ret_var = ((Popup)ws.Target).Fetch(child);
2101                 }
2102                 catch (Exception e)
2103                 {
2104                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2105                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2106                 }
2107
2108                         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
2109
2110             }
2111             else
2112             {
2113                 return efl_ui_focus_manager_fetch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
2114             }
2115         }
2116
2117         private static efl_ui_focus_manager_fetch_delegate efl_ui_focus_manager_fetch_static_delegate;
2118
2119
2120         private delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_delegate(System.IntPtr obj, System.IntPtr pd);
2121
2122
2123         public delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_api_delegate(System.IntPtr obj);
2124
2125         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");
2126
2127         private static Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct logical_end(System.IntPtr obj, System.IntPtr pd)
2128         {
2129             Eina.Log.Debug("function efl_ui_focus_manager_logical_end was called");
2130             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2131             if (ws != null)
2132             {
2133             Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
2134                 try
2135                 {
2136                     _ret_var = ((Popup)ws.Target).LogicalEnd();
2137                 }
2138                 catch (Exception e)
2139                 {
2140                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2141                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2142                 }
2143
2144         return _ret_var;
2145
2146             }
2147             else
2148             {
2149                 return efl_ui_focus_manager_logical_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2150             }
2151         }
2152
2153         private static efl_ui_focus_manager_logical_end_delegate efl_ui_focus_manager_logical_end_static_delegate;
2154
2155
2156         private delegate void efl_ui_focus_manager_reset_history_delegate(System.IntPtr obj, System.IntPtr pd);
2157
2158
2159         public delegate void efl_ui_focus_manager_reset_history_api_delegate(System.IntPtr obj);
2160
2161         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");
2162
2163         private static void reset_history(System.IntPtr obj, System.IntPtr pd)
2164         {
2165             Eina.Log.Debug("function efl_ui_focus_manager_reset_history was called");
2166             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2167             if (ws != null)
2168             {
2169
2170                 try
2171                 {
2172                     ((Popup)ws.Target).ResetHistory();
2173                 }
2174                 catch (Exception e)
2175                 {
2176                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2177                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2178                 }
2179
2180
2181             }
2182             else
2183             {
2184                 efl_ui_focus_manager_reset_history_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2185             }
2186         }
2187
2188         private static efl_ui_focus_manager_reset_history_delegate efl_ui_focus_manager_reset_history_static_delegate;
2189
2190
2191         private delegate void efl_ui_focus_manager_pop_history_stack_delegate(System.IntPtr obj, System.IntPtr pd);
2192
2193
2194         public delegate void efl_ui_focus_manager_pop_history_stack_api_delegate(System.IntPtr obj);
2195
2196         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");
2197
2198         private static void pop_history_stack(System.IntPtr obj, System.IntPtr pd)
2199         {
2200             Eina.Log.Debug("function efl_ui_focus_manager_pop_history_stack was called");
2201             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2202             if (ws != null)
2203             {
2204
2205                 try
2206                 {
2207                     ((Popup)ws.Target).PopHistoryStack();
2208                 }
2209                 catch (Exception e)
2210                 {
2211                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2212                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2213                 }
2214
2215
2216             }
2217             else
2218             {
2219                 efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2220             }
2221         }
2222
2223         private static efl_ui_focus_manager_pop_history_stack_delegate efl_ui_focus_manager_pop_history_stack_static_delegate;
2224
2225
2226         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);
2227
2228
2229         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);
2230
2231         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");
2232
2233         private static void setup_on_first_touch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry)
2234         {
2235             Eina.Log.Debug("function efl_ui_focus_manager_setup_on_first_touch was called");
2236             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2237             if (ws != null)
2238             {
2239
2240                 try
2241                 {
2242                     ((Popup)ws.Target).SetupOnFirstTouch(direction, entry);
2243                 }
2244                 catch (Exception e)
2245                 {
2246                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2247                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2248                 }
2249
2250
2251             }
2252             else
2253             {
2254                 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);
2255             }
2256         }
2257
2258         private static efl_ui_focus_manager_setup_on_first_touch_delegate efl_ui_focus_manager_setup_on_first_touch_static_delegate;
2259
2260
2261         private delegate void efl_ui_focus_manager_dirty_logic_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
2262
2263
2264         public delegate void efl_ui_focus_manager_dirty_logic_freeze_api_delegate(System.IntPtr obj);
2265
2266         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");
2267
2268         private static void dirty_logic_freeze(System.IntPtr obj, System.IntPtr pd)
2269         {
2270             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_freeze was called");
2271             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2272             if (ws != null)
2273             {
2274
2275                 try
2276                 {
2277                     ((Popup)ws.Target).FreezeDirtyLogic();
2278                 }
2279                 catch (Exception e)
2280                 {
2281                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2282                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2283                 }
2284
2285
2286             }
2287             else
2288             {
2289                 efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2290             }
2291         }
2292
2293         private static efl_ui_focus_manager_dirty_logic_freeze_delegate efl_ui_focus_manager_dirty_logic_freeze_static_delegate;
2294
2295
2296         private delegate void efl_ui_focus_manager_dirty_logic_unfreeze_delegate(System.IntPtr obj, System.IntPtr pd);
2297
2298
2299         public delegate void efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate(System.IntPtr obj);
2300
2301         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");
2302
2303         private static void dirty_logic_unfreeze(System.IntPtr obj, System.IntPtr pd)
2304         {
2305             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_unfreeze was called");
2306             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2307             if (ws != null)
2308             {
2309
2310                 try
2311                 {
2312                     ((Popup)ws.Target).DirtyLogicUnfreeze();
2313                 }
2314                 catch (Exception e)
2315                 {
2316                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2317                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2318                 }
2319
2320
2321             }
2322             else
2323             {
2324                 efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2325             }
2326         }
2327
2328         private static efl_ui_focus_manager_dirty_logic_unfreeze_delegate efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate;
2329
2330         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2331
2332 }
2333 }
2334 }
2335
2336 }
2337
2338 namespace Efl {
2339
2340 namespace Ui {
2341
2342 /// <summary>Popup alignment type</summary>
2343 [Efl.Eo.BindingEntity]
2344 public enum PopupAlign
2345 {
2346 /// <summary>Popup not aligned</summary>
2347 None = 0,
2348 /// <summary>Popup aligned to center</summary>
2349 Center = 1,
2350 /// <summary>Popup aligned to left</summary>
2351 Left = 2,
2352 /// <summary>Popup aligned to right</summary>
2353 Right = 3,
2354 /// <summary>Popup aligned to top</summary>
2355 Top = 4,
2356 /// <summary>Popup aligned to bottom</summary>
2357 Bottom = 5,
2358 }
2359
2360 }
2361
2362 }
2363