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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary></summary>
   9 /// <param name="obj">Canvas object</param>
  10 /// <param name="region">Showed region</param>
  11 /// <returns></returns>
  12 public delegate void ScrollableOnShowRegion( Efl.Canvas.Object obj,  Eina.Rect region);
  13 public delegate void ScrollableOnShowRegionInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object obj,   Eina.Rect.NativeStruct region);
  14 internal class ScrollableOnShowRegionWrapper
  15 {
  16
  17     private ScrollableOnShowRegionInternal _cb;
  18     private IntPtr _cb_data;
  19     private EinaFreeCb _cb_free_cb;
  20
  21     internal ScrollableOnShowRegionWrapper (ScrollableOnShowRegionInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  22     {
  23         this._cb = _cb;
  24         this._cb_data = _cb_data;
  25         this._cb_free_cb = _cb_free_cb;
  26     }
  27
  28     ~ScrollableOnShowRegionWrapper()
  29     {
  30         if (this._cb_free_cb != null)
  31             this._cb_free_cb(this._cb_data);
  32     }
  33
  34     internal void ManagedCb( Efl.Canvas.Object obj, Eina.Rect region)
  35     {
  36                 Eina.Rect.NativeStruct _in_region = region;
  37                                         _cb(_cb_data,  obj,  _in_region);
  38         Eina.Error.RaiseIfUnhandledException();
  39                                             }
  40
  41         internal static void Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object obj,   Eina.Rect.NativeStruct region)
  42     {
  43         GCHandle handle = GCHandle.FromIntPtr(cb_data);
  44         ScrollableOnShowRegion cb = (ScrollableOnShowRegion)handle.Target;
  45                 Eina.Rect _in_region = region;
  46
  47         try {
  48             cb( obj,  _in_region);
  49         } catch (Exception e) {
  50             Eina.Log.Warning($"Callback error: {e.ToString()}");
  51             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  52         }
  53                                             }
  54 }
  55 } }
  56 namespace Efl { namespace Ui {
  57 /// <summary>Efl UI widget abstract class
  58 /// (Since EFL 1.22)</summary>
  59 [WidgetNativeInherit]
  60 public abstract class Widget : Efl.Canvas.Group, Efl.Eo.IWrapper,Efl.IPart,Efl.Access.IAction,Efl.Access.IComponent,Efl.Access.IObject,Efl.Access.Widget.IAction,Efl.Ui.IDnd,Efl.Ui.IL10n,Efl.Ui.IPropertyBind,Efl.Ui.ISelection,Efl.Ui.IView,Efl.Ui.Focus.IObject
  61 {
  62     ///<summary>Pointer to the native class description.</summary>
  63     public override System.IntPtr NativeClass {
  64         get {
  65             if (((object)this).GetType() == typeof (Widget))
  66                 return Efl.Ui.WidgetNativeInherit.GetEflClassStatic();
  67             else
  68                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  69         }
  70     }
  71     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  72         efl_ui_widget_class_get();
  73     ///<summary>Creates a new instance.</summary>
  74     ///<param name="parent">Parent instance.</param>
  75     ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  76     public Widget(Efl.Object parent
  77             , System.String style = null) :
  78         base(efl_ui_widget_class_get(), typeof(Widget), parent)
  79     {
  80         if (Efl.Eo.Globals.ParamHelperCheck(style))
  81             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  82         FinishInstantiation();
  83     }
  84     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  85     protected Widget(System.IntPtr raw) : base(raw)
  86     {
  87                 RegisterEventProxies();
  88     }
  89     [Efl.Eo.PrivateNativeClass]
  90     private class WidgetRealized : Widget
  91     {
  92         private WidgetRealized(IntPtr ptr) : base(ptr)
  93         {
  94         }
  95     }
  96     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  97     protected Widget(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  98     ///<summary>Verifies if the given object is equal to this one.</summary>
  99     public override bool Equals(object obj)
 100     {
 101         var other = obj as Efl.Object;
 102         if (other == null)
 103             return false;
 104         return this.NativeHandle == other.NativeHandle;
 105     }
 106     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 107     public override int GetHashCode()
 108     {
 109         return this.NativeHandle.ToInt32();
 110     }
 111     ///<summary>Turns the native pointer into a string representation.</summary>
 112     public override String ToString()
 113     {
 114         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 115     }
 116 private static object AtspiHighlightedEvtKey = new object();
 117     /// <summary></summary>
 118     public event EventHandler AtspiHighlightedEvt
 119     {
 120         add {
 121             lock (eventLock) {
 122                 string key = "_EFL_UI_WIDGET_EVENT_ATSPI_HIGHLIGHTED";
 123                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_AtspiHighlightedEvt_delegate)) {
 124                     eventHandlers.AddHandler(AtspiHighlightedEvtKey , value);
 125                 } else
 126                     Eina.Log.Error($"Error adding proxy for event {key}");
 127             }
 128         }
 129         remove {
 130             lock (eventLock) {
 131                 string key = "_EFL_UI_WIDGET_EVENT_ATSPI_HIGHLIGHTED";
 132                 if (RemoveNativeEventHandler(key, this.evt_AtspiHighlightedEvt_delegate)) {
 133                     eventHandlers.RemoveHandler(AtspiHighlightedEvtKey , value);
 134                 } else
 135                     Eina.Log.Error($"Error removing proxy for event {key}");
 136             }
 137         }
 138     }
 139     ///<summary>Method to raise event AtspiHighlightedEvt.</summary>
 140     public void On_AtspiHighlightedEvt(EventArgs e)
 141     {
 142         EventHandler evt;
 143         lock (eventLock) {
 144         evt = (EventHandler)eventHandlers[AtspiHighlightedEvtKey];
 145         }
 146         evt?.Invoke(this, e);
 147     }
 148     Efl.EventCb evt_AtspiHighlightedEvt_delegate;
 149     private void on_AtspiHighlightedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 150     {
 151         EventArgs args = EventArgs.Empty;
 152         try {
 153             On_AtspiHighlightedEvt(args);
 154         } catch (Exception e) {
 155             Eina.Log.Error(e.ToString());
 156             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 157         }
 158     }
 159
 160 private static object AtspiUnhighlightedEvtKey = new object();
 161     /// <summary></summary>
 162     public event EventHandler AtspiUnhighlightedEvt
 163     {
 164         add {
 165             lock (eventLock) {
 166                 string key = "_EFL_UI_WIDGET_EVENT_ATSPI_UNHIGHLIGHTED";
 167                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_AtspiUnhighlightedEvt_delegate)) {
 168                     eventHandlers.AddHandler(AtspiUnhighlightedEvtKey , value);
 169                 } else
 170                     Eina.Log.Error($"Error adding proxy for event {key}");
 171             }
 172         }
 173         remove {
 174             lock (eventLock) {
 175                 string key = "_EFL_UI_WIDGET_EVENT_ATSPI_UNHIGHLIGHTED";
 176                 if (RemoveNativeEventHandler(key, this.evt_AtspiUnhighlightedEvt_delegate)) {
 177                     eventHandlers.RemoveHandler(AtspiUnhighlightedEvtKey , value);
 178                 } else
 179                     Eina.Log.Error($"Error removing proxy for event {key}");
 180             }
 181         }
 182     }
 183     ///<summary>Method to raise event AtspiUnhighlightedEvt.</summary>
 184     public void On_AtspiUnhighlightedEvt(EventArgs e)
 185     {
 186         EventHandler evt;
 187         lock (eventLock) {
 188         evt = (EventHandler)eventHandlers[AtspiUnhighlightedEvtKey];
 189         }
 190         evt?.Invoke(this, e);
 191     }
 192     Efl.EventCb evt_AtspiUnhighlightedEvt_delegate;
 193     private void on_AtspiUnhighlightedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 194     {
 195         EventArgs args = EventArgs.Empty;
 196         try {
 197             On_AtspiUnhighlightedEvt(args);
 198         } catch (Exception e) {
 199             Eina.Log.Error(e.ToString());
 200             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 201         }
 202     }
 203
 204 private static object LanguageChangedEvtKey = new object();
 205     /// <summary>Called when widget language changed
 206     /// (Since EFL 1.22)</summary>
 207     public event EventHandler LanguageChangedEvt
 208     {
 209         add {
 210             lock (eventLock) {
 211                 string key = "_EFL_UI_WIDGET_EVENT_LANGUAGE_CHANGED";
 212                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_LanguageChangedEvt_delegate)) {
 213                     eventHandlers.AddHandler(LanguageChangedEvtKey , value);
 214                 } else
 215                     Eina.Log.Error($"Error adding proxy for event {key}");
 216             }
 217         }
 218         remove {
 219             lock (eventLock) {
 220                 string key = "_EFL_UI_WIDGET_EVENT_LANGUAGE_CHANGED";
 221                 if (RemoveNativeEventHandler(key, this.evt_LanguageChangedEvt_delegate)) {
 222                     eventHandlers.RemoveHandler(LanguageChangedEvtKey , value);
 223                 } else
 224                     Eina.Log.Error($"Error removing proxy for event {key}");
 225             }
 226         }
 227     }
 228     ///<summary>Method to raise event LanguageChangedEvt.</summary>
 229     public void On_LanguageChangedEvt(EventArgs e)
 230     {
 231         EventHandler evt;
 232         lock (eventLock) {
 233         evt = (EventHandler)eventHandlers[LanguageChangedEvtKey];
 234         }
 235         evt?.Invoke(this, e);
 236     }
 237     Efl.EventCb evt_LanguageChangedEvt_delegate;
 238     private void on_LanguageChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 239     {
 240         EventArgs args = EventArgs.Empty;
 241         try {
 242             On_LanguageChangedEvt(args);
 243         } catch (Exception e) {
 244             Eina.Log.Error(e.ToString());
 245             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 246         }
 247     }
 248
 249 private static object AccessChangedEvtKey = new object();
 250     /// <summary>Called when accessibility changed
 251     /// (Since EFL 1.22)</summary>
 252     public event EventHandler AccessChangedEvt
 253     {
 254         add {
 255             lock (eventLock) {
 256                 string key = "_EFL_UI_WIDGET_EVENT_ACCESS_CHANGED";
 257                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_AccessChangedEvt_delegate)) {
 258                     eventHandlers.AddHandler(AccessChangedEvtKey , value);
 259                 } else
 260                     Eina.Log.Error($"Error adding proxy for event {key}");
 261             }
 262         }
 263         remove {
 264             lock (eventLock) {
 265                 string key = "_EFL_UI_WIDGET_EVENT_ACCESS_CHANGED";
 266                 if (RemoveNativeEventHandler(key, this.evt_AccessChangedEvt_delegate)) {
 267                     eventHandlers.RemoveHandler(AccessChangedEvtKey , value);
 268                 } else
 269                     Eina.Log.Error($"Error removing proxy for event {key}");
 270             }
 271         }
 272     }
 273     ///<summary>Method to raise event AccessChangedEvt.</summary>
 274     public void On_AccessChangedEvt(EventArgs e)
 275     {
 276         EventHandler evt;
 277         lock (eventLock) {
 278         evt = (EventHandler)eventHandlers[AccessChangedEvtKey];
 279         }
 280         evt?.Invoke(this, e);
 281     }
 282     Efl.EventCb evt_AccessChangedEvt_delegate;
 283     private void on_AccessChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 284     {
 285         EventArgs args = EventArgs.Empty;
 286         try {
 287             On_AccessChangedEvt(args);
 288         } catch (Exception e) {
 289             Eina.Log.Error(e.ToString());
 290             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 291         }
 292     }
 293
 294 private static object PropertyChangedEvtKey = new object();
 295     /// <summary>Called when property has changed</summary>
 296     public event EventHandler<Efl.Access.IObjectPropertyChangedEvt_Args> PropertyChangedEvt
 297     {
 298         add {
 299             lock (eventLock) {
 300                 string key = "_EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED";
 301                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_PropertyChangedEvt_delegate)) {
 302                     eventHandlers.AddHandler(PropertyChangedEvtKey , value);
 303                 } else
 304                     Eina.Log.Error($"Error adding proxy for event {key}");
 305             }
 306         }
 307         remove {
 308             lock (eventLock) {
 309                 string key = "_EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED";
 310                 if (RemoveNativeEventHandler(key, this.evt_PropertyChangedEvt_delegate)) {
 311                     eventHandlers.RemoveHandler(PropertyChangedEvtKey , value);
 312                 } else
 313                     Eina.Log.Error($"Error removing proxy for event {key}");
 314             }
 315         }
 316     }
 317     ///<summary>Method to raise event PropertyChangedEvt.</summary>
 318     public void On_PropertyChangedEvt(Efl.Access.IObjectPropertyChangedEvt_Args e)
 319     {
 320         EventHandler<Efl.Access.IObjectPropertyChangedEvt_Args> evt;
 321         lock (eventLock) {
 322         evt = (EventHandler<Efl.Access.IObjectPropertyChangedEvt_Args>)eventHandlers[PropertyChangedEvtKey];
 323         }
 324         evt?.Invoke(this, e);
 325     }
 326     Efl.EventCb evt_PropertyChangedEvt_delegate;
 327     private void on_PropertyChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 328     {
 329         Efl.Access.IObjectPropertyChangedEvt_Args args = new Efl.Access.IObjectPropertyChangedEvt_Args();
 330       args.arg = Eina.StringConversion.NativeUtf8ToManagedString(evt.Info);
 331         try {
 332             On_PropertyChangedEvt(args);
 333         } catch (Exception e) {
 334             Eina.Log.Error(e.ToString());
 335             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 336         }
 337     }
 338
 339 private static object ChildrenChangedEvtKey = new object();
 340     /// <summary>Called when children have changed</summary>
 341     public event EventHandler<Efl.Access.IObjectChildrenChangedEvt_Args> ChildrenChangedEvt
 342     {
 343         add {
 344             lock (eventLock) {
 345                 string key = "_EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED";
 346                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_ChildrenChangedEvt_delegate)) {
 347                     eventHandlers.AddHandler(ChildrenChangedEvtKey , value);
 348                 } else
 349                     Eina.Log.Error($"Error adding proxy for event {key}");
 350             }
 351         }
 352         remove {
 353             lock (eventLock) {
 354                 string key = "_EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED";
 355                 if (RemoveNativeEventHandler(key, this.evt_ChildrenChangedEvt_delegate)) {
 356                     eventHandlers.RemoveHandler(ChildrenChangedEvtKey , value);
 357                 } else
 358                     Eina.Log.Error($"Error removing proxy for event {key}");
 359             }
 360         }
 361     }
 362     ///<summary>Method to raise event ChildrenChangedEvt.</summary>
 363     public void On_ChildrenChangedEvt(Efl.Access.IObjectChildrenChangedEvt_Args e)
 364     {
 365         EventHandler<Efl.Access.IObjectChildrenChangedEvt_Args> evt;
 366         lock (eventLock) {
 367         evt = (EventHandler<Efl.Access.IObjectChildrenChangedEvt_Args>)eventHandlers[ChildrenChangedEvtKey];
 368         }
 369         evt?.Invoke(this, e);
 370     }
 371     Efl.EventCb evt_ChildrenChangedEvt_delegate;
 372     private void on_ChildrenChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 373     {
 374         Efl.Access.IObjectChildrenChangedEvt_Args args = new Efl.Access.IObjectChildrenChangedEvt_Args();
 375       args.arg =  evt.Info;;
 376         try {
 377             On_ChildrenChangedEvt(args);
 378         } catch (Exception e) {
 379             Eina.Log.Error(e.ToString());
 380             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 381         }
 382     }
 383
 384 private static object StateChangedEvtKey = new object();
 385     /// <summary>Called when state has changed</summary>
 386     public event EventHandler<Efl.Access.IObjectStateChangedEvt_Args> StateChangedEvt
 387     {
 388         add {
 389             lock (eventLock) {
 390                 string key = "_EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED";
 391                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_StateChangedEvt_delegate)) {
 392                     eventHandlers.AddHandler(StateChangedEvtKey , value);
 393                 } else
 394                     Eina.Log.Error($"Error adding proxy for event {key}");
 395             }
 396         }
 397         remove {
 398             lock (eventLock) {
 399                 string key = "_EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED";
 400                 if (RemoveNativeEventHandler(key, this.evt_StateChangedEvt_delegate)) {
 401                     eventHandlers.RemoveHandler(StateChangedEvtKey , value);
 402                 } else
 403                     Eina.Log.Error($"Error removing proxy for event {key}");
 404             }
 405         }
 406     }
 407     ///<summary>Method to raise event StateChangedEvt.</summary>
 408     public void On_StateChangedEvt(Efl.Access.IObjectStateChangedEvt_Args e)
 409     {
 410         EventHandler<Efl.Access.IObjectStateChangedEvt_Args> evt;
 411         lock (eventLock) {
 412         evt = (EventHandler<Efl.Access.IObjectStateChangedEvt_Args>)eventHandlers[StateChangedEvtKey];
 413         }
 414         evt?.Invoke(this, e);
 415     }
 416     Efl.EventCb evt_StateChangedEvt_delegate;
 417     private void on_StateChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 418     {
 419         Efl.Access.IObjectStateChangedEvt_Args args = new Efl.Access.IObjectStateChangedEvt_Args();
 420       args.arg =  evt.Info;;
 421         try {
 422             On_StateChangedEvt(args);
 423         } catch (Exception e) {
 424             Eina.Log.Error(e.ToString());
 425             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 426         }
 427     }
 428
 429 private static object BoundsChangedEvtKey = new object();
 430     /// <summary>Called when boundaries have changed</summary>
 431     public event EventHandler<Efl.Access.IObjectBoundsChangedEvt_Args> BoundsChangedEvt
 432     {
 433         add {
 434             lock (eventLock) {
 435                 string key = "_EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED";
 436                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_BoundsChangedEvt_delegate)) {
 437                     eventHandlers.AddHandler(BoundsChangedEvtKey , value);
 438                 } else
 439                     Eina.Log.Error($"Error adding proxy for event {key}");
 440             }
 441         }
 442         remove {
 443             lock (eventLock) {
 444                 string key = "_EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED";
 445                 if (RemoveNativeEventHandler(key, this.evt_BoundsChangedEvt_delegate)) {
 446                     eventHandlers.RemoveHandler(BoundsChangedEvtKey , value);
 447                 } else
 448                     Eina.Log.Error($"Error removing proxy for event {key}");
 449             }
 450         }
 451     }
 452     ///<summary>Method to raise event BoundsChangedEvt.</summary>
 453     public void On_BoundsChangedEvt(Efl.Access.IObjectBoundsChangedEvt_Args e)
 454     {
 455         EventHandler<Efl.Access.IObjectBoundsChangedEvt_Args> evt;
 456         lock (eventLock) {
 457         evt = (EventHandler<Efl.Access.IObjectBoundsChangedEvt_Args>)eventHandlers[BoundsChangedEvtKey];
 458         }
 459         evt?.Invoke(this, e);
 460     }
 461     Efl.EventCb evt_BoundsChangedEvt_delegate;
 462     private void on_BoundsChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 463     {
 464         Efl.Access.IObjectBoundsChangedEvt_Args args = new Efl.Access.IObjectBoundsChangedEvt_Args();
 465       args.arg =  evt.Info;;
 466         try {
 467             On_BoundsChangedEvt(args);
 468         } catch (Exception e) {
 469             Eina.Log.Error(e.ToString());
 470             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 471         }
 472     }
 473
 474 private static object VisibleDataChangedEvtKey = new object();
 475     /// <summary>Called when visibility has changed</summary>
 476     public event EventHandler VisibleDataChangedEvt
 477     {
 478         add {
 479             lock (eventLock) {
 480                 string key = "_EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED";
 481                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_VisibleDataChangedEvt_delegate)) {
 482                     eventHandlers.AddHandler(VisibleDataChangedEvtKey , value);
 483                 } else
 484                     Eina.Log.Error($"Error adding proxy for event {key}");
 485             }
 486         }
 487         remove {
 488             lock (eventLock) {
 489                 string key = "_EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED";
 490                 if (RemoveNativeEventHandler(key, this.evt_VisibleDataChangedEvt_delegate)) {
 491                     eventHandlers.RemoveHandler(VisibleDataChangedEvtKey , value);
 492                 } else
 493                     Eina.Log.Error($"Error removing proxy for event {key}");
 494             }
 495         }
 496     }
 497     ///<summary>Method to raise event VisibleDataChangedEvt.</summary>
 498     public void On_VisibleDataChangedEvt(EventArgs e)
 499     {
 500         EventHandler evt;
 501         lock (eventLock) {
 502         evt = (EventHandler)eventHandlers[VisibleDataChangedEvtKey];
 503         }
 504         evt?.Invoke(this, e);
 505     }
 506     Efl.EventCb evt_VisibleDataChangedEvt_delegate;
 507     private void on_VisibleDataChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 508     {
 509         EventArgs args = EventArgs.Empty;
 510         try {
 511             On_VisibleDataChangedEvt(args);
 512         } catch (Exception e) {
 513             Eina.Log.Error(e.ToString());
 514             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 515         }
 516     }
 517
 518 private static object ActiveDescendantChangedEvtKey = new object();
 519     /// <summary>Called when active state of descendant has changed</summary>
 520     public event EventHandler<Efl.Access.IObjectActiveDescendantChangedEvt_Args> ActiveDescendantChangedEvt
 521     {
 522         add {
 523             lock (eventLock) {
 524                 string key = "_EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED";
 525                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_ActiveDescendantChangedEvt_delegate)) {
 526                     eventHandlers.AddHandler(ActiveDescendantChangedEvtKey , value);
 527                 } else
 528                     Eina.Log.Error($"Error adding proxy for event {key}");
 529             }
 530         }
 531         remove {
 532             lock (eventLock) {
 533                 string key = "_EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED";
 534                 if (RemoveNativeEventHandler(key, this.evt_ActiveDescendantChangedEvt_delegate)) {
 535                     eventHandlers.RemoveHandler(ActiveDescendantChangedEvtKey , value);
 536                 } else
 537                     Eina.Log.Error($"Error removing proxy for event {key}");
 538             }
 539         }
 540     }
 541     ///<summary>Method to raise event ActiveDescendantChangedEvt.</summary>
 542     public void On_ActiveDescendantChangedEvt(Efl.Access.IObjectActiveDescendantChangedEvt_Args e)
 543     {
 544         EventHandler<Efl.Access.IObjectActiveDescendantChangedEvt_Args> evt;
 545         lock (eventLock) {
 546         evt = (EventHandler<Efl.Access.IObjectActiveDescendantChangedEvt_Args>)eventHandlers[ActiveDescendantChangedEvtKey];
 547         }
 548         evt?.Invoke(this, e);
 549     }
 550     Efl.EventCb evt_ActiveDescendantChangedEvt_delegate;
 551     private void on_ActiveDescendantChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 552     {
 553         Efl.Access.IObjectActiveDescendantChangedEvt_Args args = new Efl.Access.IObjectActiveDescendantChangedEvt_Args();
 554       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 555         try {
 556             On_ActiveDescendantChangedEvt(args);
 557         } catch (Exception e) {
 558             Eina.Log.Error(e.ToString());
 559             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 560         }
 561     }
 562
 563 private static object AddedEvtKey = new object();
 564     /// <summary>Called when item is added</summary>
 565     public event EventHandler AddedEvt
 566     {
 567         add {
 568             lock (eventLock) {
 569                 string key = "_EFL_ACCESS_OBJECT_EVENT_ADDED";
 570                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_AddedEvt_delegate)) {
 571                     eventHandlers.AddHandler(AddedEvtKey , value);
 572                 } else
 573                     Eina.Log.Error($"Error adding proxy for event {key}");
 574             }
 575         }
 576         remove {
 577             lock (eventLock) {
 578                 string key = "_EFL_ACCESS_OBJECT_EVENT_ADDED";
 579                 if (RemoveNativeEventHandler(key, this.evt_AddedEvt_delegate)) {
 580                     eventHandlers.RemoveHandler(AddedEvtKey , value);
 581                 } else
 582                     Eina.Log.Error($"Error removing proxy for event {key}");
 583             }
 584         }
 585     }
 586     ///<summary>Method to raise event AddedEvt.</summary>
 587     public void On_AddedEvt(EventArgs e)
 588     {
 589         EventHandler evt;
 590         lock (eventLock) {
 591         evt = (EventHandler)eventHandlers[AddedEvtKey];
 592         }
 593         evt?.Invoke(this, e);
 594     }
 595     Efl.EventCb evt_AddedEvt_delegate;
 596     private void on_AddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 597     {
 598         EventArgs args = EventArgs.Empty;
 599         try {
 600             On_AddedEvt(args);
 601         } catch (Exception e) {
 602             Eina.Log.Error(e.ToString());
 603             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 604         }
 605     }
 606
 607 private static object RemovedEvtKey = new object();
 608     /// <summary>Called when item is removed</summary>
 609     public event EventHandler RemovedEvt
 610     {
 611         add {
 612             lock (eventLock) {
 613                 string key = "_EFL_ACCESS_OBJECT_EVENT_REMOVED";
 614                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_RemovedEvt_delegate)) {
 615                     eventHandlers.AddHandler(RemovedEvtKey , value);
 616                 } else
 617                     Eina.Log.Error($"Error adding proxy for event {key}");
 618             }
 619         }
 620         remove {
 621             lock (eventLock) {
 622                 string key = "_EFL_ACCESS_OBJECT_EVENT_REMOVED";
 623                 if (RemoveNativeEventHandler(key, this.evt_RemovedEvt_delegate)) {
 624                     eventHandlers.RemoveHandler(RemovedEvtKey , value);
 625                 } else
 626                     Eina.Log.Error($"Error removing proxy for event {key}");
 627             }
 628         }
 629     }
 630     ///<summary>Method to raise event RemovedEvt.</summary>
 631     public void On_RemovedEvt(EventArgs e)
 632     {
 633         EventHandler evt;
 634         lock (eventLock) {
 635         evt = (EventHandler)eventHandlers[RemovedEvtKey];
 636         }
 637         evt?.Invoke(this, e);
 638     }
 639     Efl.EventCb evt_RemovedEvt_delegate;
 640     private void on_RemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 641     {
 642         EventArgs args = EventArgs.Empty;
 643         try {
 644             On_RemovedEvt(args);
 645         } catch (Exception e) {
 646             Eina.Log.Error(e.ToString());
 647             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 648         }
 649     }
 650
 651 private static object MoveOutedEvtKey = new object();
 652     /// <summary></summary>
 653     public event EventHandler MoveOutedEvt
 654     {
 655         add {
 656             lock (eventLock) {
 657                 string key = "_EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED";
 658                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_MoveOutedEvt_delegate)) {
 659                     eventHandlers.AddHandler(MoveOutedEvtKey , value);
 660                 } else
 661                     Eina.Log.Error($"Error adding proxy for event {key}");
 662             }
 663         }
 664         remove {
 665             lock (eventLock) {
 666                 string key = "_EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED";
 667                 if (RemoveNativeEventHandler(key, this.evt_MoveOutedEvt_delegate)) {
 668                     eventHandlers.RemoveHandler(MoveOutedEvtKey , value);
 669                 } else
 670                     Eina.Log.Error($"Error removing proxy for event {key}");
 671             }
 672         }
 673     }
 674     ///<summary>Method to raise event MoveOutedEvt.</summary>
 675     public void On_MoveOutedEvt(EventArgs e)
 676     {
 677         EventHandler evt;
 678         lock (eventLock) {
 679         evt = (EventHandler)eventHandlers[MoveOutedEvtKey];
 680         }
 681         evt?.Invoke(this, e);
 682     }
 683     Efl.EventCb evt_MoveOutedEvt_delegate;
 684     private void on_MoveOutedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 685     {
 686         EventArgs args = EventArgs.Empty;
 687         try {
 688             On_MoveOutedEvt(args);
 689         } catch (Exception e) {
 690             Eina.Log.Error(e.ToString());
 691             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 692         }
 693     }
 694
 695 private static object ReadingStateChangedEvtKey = new object();
 696     /// <summary></summary>
 697     public event EventHandler ReadingStateChangedEvt
 698     {
 699         add {
 700             lock (eventLock) {
 701                 string key = "_EFL_ACCESS_WIDGET_ACTION_EVENT_READING_STATE_CHANGED";
 702                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_ReadingStateChangedEvt_delegate)) {
 703                     eventHandlers.AddHandler(ReadingStateChangedEvtKey , value);
 704                 } else
 705                     Eina.Log.Error($"Error adding proxy for event {key}");
 706             }
 707         }
 708         remove {
 709             lock (eventLock) {
 710                 string key = "_EFL_ACCESS_WIDGET_ACTION_EVENT_READING_STATE_CHANGED";
 711                 if (RemoveNativeEventHandler(key, this.evt_ReadingStateChangedEvt_delegate)) {
 712                     eventHandlers.RemoveHandler(ReadingStateChangedEvtKey , value);
 713                 } else
 714                     Eina.Log.Error($"Error removing proxy for event {key}");
 715             }
 716         }
 717     }
 718     ///<summary>Method to raise event ReadingStateChangedEvt.</summary>
 719     public void On_ReadingStateChangedEvt(EventArgs e)
 720     {
 721         EventHandler evt;
 722         lock (eventLock) {
 723         evt = (EventHandler)eventHandlers[ReadingStateChangedEvtKey];
 724         }
 725         evt?.Invoke(this, e);
 726     }
 727     Efl.EventCb evt_ReadingStateChangedEvt_delegate;
 728     private void on_ReadingStateChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 729     {
 730         EventArgs args = EventArgs.Empty;
 731         try {
 732             On_ReadingStateChangedEvt(args);
 733         } catch (Exception e) {
 734             Eina.Log.Error(e.ToString());
 735             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 736         }
 737     }
 738
 739 private static object DragAcceptEvtKey = new object();
 740     /// <summary>accept drag data</summary>
 741     public event EventHandler<Efl.Ui.IDndDragAcceptEvt_Args> DragAcceptEvt
 742     {
 743         add {
 744             lock (eventLock) {
 745                 string key = "_EFL_UI_DND_EVENT_DRAG_ACCEPT";
 746                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragAcceptEvt_delegate)) {
 747                     eventHandlers.AddHandler(DragAcceptEvtKey , value);
 748                 } else
 749                     Eina.Log.Error($"Error adding proxy for event {key}");
 750             }
 751         }
 752         remove {
 753             lock (eventLock) {
 754                 string key = "_EFL_UI_DND_EVENT_DRAG_ACCEPT";
 755                 if (RemoveNativeEventHandler(key, this.evt_DragAcceptEvt_delegate)) {
 756                     eventHandlers.RemoveHandler(DragAcceptEvtKey , value);
 757                 } else
 758                     Eina.Log.Error($"Error removing proxy for event {key}");
 759             }
 760         }
 761     }
 762     ///<summary>Method to raise event DragAcceptEvt.</summary>
 763     public void On_DragAcceptEvt(Efl.Ui.IDndDragAcceptEvt_Args e)
 764     {
 765         EventHandler<Efl.Ui.IDndDragAcceptEvt_Args> evt;
 766         lock (eventLock) {
 767         evt = (EventHandler<Efl.Ui.IDndDragAcceptEvt_Args>)eventHandlers[DragAcceptEvtKey];
 768         }
 769         evt?.Invoke(this, e);
 770     }
 771     Efl.EventCb evt_DragAcceptEvt_delegate;
 772     private void on_DragAcceptEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 773     {
 774         Efl.Ui.IDndDragAcceptEvt_Args args = new Efl.Ui.IDndDragAcceptEvt_Args();
 775       args.arg = (bool)Marshal.PtrToStructure(evt.Info, typeof(bool));
 776         try {
 777             On_DragAcceptEvt(args);
 778         } catch (Exception e) {
 779             Eina.Log.Error(e.ToString());
 780             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 781         }
 782     }
 783
 784 private static object DragDoneEvtKey = new object();
 785     /// <summary>drag is done (mouse up)</summary>
 786     public event EventHandler DragDoneEvt
 787     {
 788         add {
 789             lock (eventLock) {
 790                 string key = "_EFL_UI_DND_EVENT_DRAG_DONE";
 791                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragDoneEvt_delegate)) {
 792                     eventHandlers.AddHandler(DragDoneEvtKey , value);
 793                 } else
 794                     Eina.Log.Error($"Error adding proxy for event {key}");
 795             }
 796         }
 797         remove {
 798             lock (eventLock) {
 799                 string key = "_EFL_UI_DND_EVENT_DRAG_DONE";
 800                 if (RemoveNativeEventHandler(key, this.evt_DragDoneEvt_delegate)) {
 801                     eventHandlers.RemoveHandler(DragDoneEvtKey , value);
 802                 } else
 803                     Eina.Log.Error($"Error removing proxy for event {key}");
 804             }
 805         }
 806     }
 807     ///<summary>Method to raise event DragDoneEvt.</summary>
 808     public void On_DragDoneEvt(EventArgs e)
 809     {
 810         EventHandler evt;
 811         lock (eventLock) {
 812         evt = (EventHandler)eventHandlers[DragDoneEvtKey];
 813         }
 814         evt?.Invoke(this, e);
 815     }
 816     Efl.EventCb evt_DragDoneEvt_delegate;
 817     private void on_DragDoneEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 818     {
 819         EventArgs args = EventArgs.Empty;
 820         try {
 821             On_DragDoneEvt(args);
 822         } catch (Exception e) {
 823             Eina.Log.Error(e.ToString());
 824             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 825         }
 826     }
 827
 828 private static object DragEnterEvtKey = new object();
 829     /// <summary>called when the drag object enters this object</summary>
 830     public event EventHandler DragEnterEvt
 831     {
 832         add {
 833             lock (eventLock) {
 834                 string key = "_EFL_UI_DND_EVENT_DRAG_ENTER";
 835                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragEnterEvt_delegate)) {
 836                     eventHandlers.AddHandler(DragEnterEvtKey , value);
 837                 } else
 838                     Eina.Log.Error($"Error adding proxy for event {key}");
 839             }
 840         }
 841         remove {
 842             lock (eventLock) {
 843                 string key = "_EFL_UI_DND_EVENT_DRAG_ENTER";
 844                 if (RemoveNativeEventHandler(key, this.evt_DragEnterEvt_delegate)) {
 845                     eventHandlers.RemoveHandler(DragEnterEvtKey , value);
 846                 } else
 847                     Eina.Log.Error($"Error removing proxy for event {key}");
 848             }
 849         }
 850     }
 851     ///<summary>Method to raise event DragEnterEvt.</summary>
 852     public void On_DragEnterEvt(EventArgs e)
 853     {
 854         EventHandler evt;
 855         lock (eventLock) {
 856         evt = (EventHandler)eventHandlers[DragEnterEvtKey];
 857         }
 858         evt?.Invoke(this, e);
 859     }
 860     Efl.EventCb evt_DragEnterEvt_delegate;
 861     private void on_DragEnterEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 862     {
 863         EventArgs args = EventArgs.Empty;
 864         try {
 865             On_DragEnterEvt(args);
 866         } catch (Exception e) {
 867             Eina.Log.Error(e.ToString());
 868             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 869         }
 870     }
 871
 872 private static object DragLeaveEvtKey = new object();
 873     /// <summary>called when the drag object leaves this object</summary>
 874     public event EventHandler DragLeaveEvt
 875     {
 876         add {
 877             lock (eventLock) {
 878                 string key = "_EFL_UI_DND_EVENT_DRAG_LEAVE";
 879                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragLeaveEvt_delegate)) {
 880                     eventHandlers.AddHandler(DragLeaveEvtKey , value);
 881                 } else
 882                     Eina.Log.Error($"Error adding proxy for event {key}");
 883             }
 884         }
 885         remove {
 886             lock (eventLock) {
 887                 string key = "_EFL_UI_DND_EVENT_DRAG_LEAVE";
 888                 if (RemoveNativeEventHandler(key, this.evt_DragLeaveEvt_delegate)) {
 889                     eventHandlers.RemoveHandler(DragLeaveEvtKey , value);
 890                 } else
 891                     Eina.Log.Error($"Error removing proxy for event {key}");
 892             }
 893         }
 894     }
 895     ///<summary>Method to raise event DragLeaveEvt.</summary>
 896     public void On_DragLeaveEvt(EventArgs e)
 897     {
 898         EventHandler evt;
 899         lock (eventLock) {
 900         evt = (EventHandler)eventHandlers[DragLeaveEvtKey];
 901         }
 902         evt?.Invoke(this, e);
 903     }
 904     Efl.EventCb evt_DragLeaveEvt_delegate;
 905     private void on_DragLeaveEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 906     {
 907         EventArgs args = EventArgs.Empty;
 908         try {
 909             On_DragLeaveEvt(args);
 910         } catch (Exception e) {
 911             Eina.Log.Error(e.ToString());
 912             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 913         }
 914     }
 915
 916 private static object DragPosEvtKey = new object();
 917     /// <summary>called when the drag object changes drag position</summary>
 918     public event EventHandler<Efl.Ui.IDndDragPosEvt_Args> DragPosEvt
 919     {
 920         add {
 921             lock (eventLock) {
 922                 string key = "_EFL_UI_DND_EVENT_DRAG_POS";
 923                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragPosEvt_delegate)) {
 924                     eventHandlers.AddHandler(DragPosEvtKey , value);
 925                 } else
 926                     Eina.Log.Error($"Error adding proxy for event {key}");
 927             }
 928         }
 929         remove {
 930             lock (eventLock) {
 931                 string key = "_EFL_UI_DND_EVENT_DRAG_POS";
 932                 if (RemoveNativeEventHandler(key, this.evt_DragPosEvt_delegate)) {
 933                     eventHandlers.RemoveHandler(DragPosEvtKey , value);
 934                 } else
 935                     Eina.Log.Error($"Error removing proxy for event {key}");
 936             }
 937         }
 938     }
 939     ///<summary>Method to raise event DragPosEvt.</summary>
 940     public void On_DragPosEvt(Efl.Ui.IDndDragPosEvt_Args e)
 941     {
 942         EventHandler<Efl.Ui.IDndDragPosEvt_Args> evt;
 943         lock (eventLock) {
 944         evt = (EventHandler<Efl.Ui.IDndDragPosEvt_Args>)eventHandlers[DragPosEvtKey];
 945         }
 946         evt?.Invoke(this, e);
 947     }
 948     Efl.EventCb evt_DragPosEvt_delegate;
 949     private void on_DragPosEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 950     {
 951         Efl.Ui.IDndDragPosEvt_Args args = new Efl.Ui.IDndDragPosEvt_Args();
 952       args.arg =  evt.Info;;
 953         try {
 954             On_DragPosEvt(args);
 955         } catch (Exception e) {
 956             Eina.Log.Error(e.ToString());
 957             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 958         }
 959     }
 960
 961 private static object DragDropEvtKey = new object();
 962     /// <summary>called when the drag object dropped on this object</summary>
 963     public event EventHandler<Efl.Ui.IDndDragDropEvt_Args> DragDropEvt
 964     {
 965         add {
 966             lock (eventLock) {
 967                 string key = "_EFL_UI_DND_EVENT_DRAG_DROP";
 968                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_DragDropEvt_delegate)) {
 969                     eventHandlers.AddHandler(DragDropEvtKey , value);
 970                 } else
 971                     Eina.Log.Error($"Error adding proxy for event {key}");
 972             }
 973         }
 974         remove {
 975             lock (eventLock) {
 976                 string key = "_EFL_UI_DND_EVENT_DRAG_DROP";
 977                 if (RemoveNativeEventHandler(key, this.evt_DragDropEvt_delegate)) {
 978                     eventHandlers.RemoveHandler(DragDropEvtKey , value);
 979                 } else
 980                     Eina.Log.Error($"Error removing proxy for event {key}");
 981             }
 982         }
 983     }
 984     ///<summary>Method to raise event DragDropEvt.</summary>
 985     public void On_DragDropEvt(Efl.Ui.IDndDragDropEvt_Args e)
 986     {
 987         EventHandler<Efl.Ui.IDndDragDropEvt_Args> evt;
 988         lock (eventLock) {
 989         evt = (EventHandler<Efl.Ui.IDndDragDropEvt_Args>)eventHandlers[DragDropEvtKey];
 990         }
 991         evt?.Invoke(this, e);
 992     }
 993     Efl.EventCb evt_DragDropEvt_delegate;
 994     private void on_DragDropEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 995     {
 996         Efl.Ui.IDndDragDropEvt_Args args = new Efl.Ui.IDndDragDropEvt_Args();
 997       args.arg =  evt.Info;;
 998         try {
 999             On_DragDropEvt(args);
1000         } catch (Exception e) {
1001             Eina.Log.Error(e.ToString());
1002             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1003         }
1004     }
1005
1006 private static object PropertiesChangedEvtKey = new object();
1007     /// <summary>Event dispatched when a property on the object has changed due to an user interaction on the object that a model could be interested in.</summary>
1008     public event EventHandler<Efl.Ui.IPropertyBindPropertiesChangedEvt_Args> PropertiesChangedEvt
1009     {
1010         add {
1011             lock (eventLock) {
1012                 string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
1013                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_PropertiesChangedEvt_delegate)) {
1014                     eventHandlers.AddHandler(PropertiesChangedEvtKey , value);
1015                 } else
1016                     Eina.Log.Error($"Error adding proxy for event {key}");
1017             }
1018         }
1019         remove {
1020             lock (eventLock) {
1021                 string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
1022                 if (RemoveNativeEventHandler(key, this.evt_PropertiesChangedEvt_delegate)) {
1023                     eventHandlers.RemoveHandler(PropertiesChangedEvtKey , value);
1024                 } else
1025                     Eina.Log.Error($"Error removing proxy for event {key}");
1026             }
1027         }
1028     }
1029     ///<summary>Method to raise event PropertiesChangedEvt.</summary>
1030     public void On_PropertiesChangedEvt(Efl.Ui.IPropertyBindPropertiesChangedEvt_Args e)
1031     {
1032         EventHandler<Efl.Ui.IPropertyBindPropertiesChangedEvt_Args> evt;
1033         lock (eventLock) {
1034         evt = (EventHandler<Efl.Ui.IPropertyBindPropertiesChangedEvt_Args>)eventHandlers[PropertiesChangedEvtKey];
1035         }
1036         evt?.Invoke(this, e);
1037     }
1038     Efl.EventCb evt_PropertiesChangedEvt_delegate;
1039     private void on_PropertiesChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1040     {
1041         Efl.Ui.IPropertyBindPropertiesChangedEvt_Args args = new Efl.Ui.IPropertyBindPropertiesChangedEvt_Args();
1042       args.arg =  evt.Info;;
1043         try {
1044             On_PropertiesChangedEvt(args);
1045         } catch (Exception e) {
1046             Eina.Log.Error(e.ToString());
1047             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1048         }
1049     }
1050
1051 private static object PropertyBoundEvtKey = new object();
1052     /// <summary>Event dispatched when a property on the object is bound to a model. This is useful to not overgenerate event.</summary>
1053     public event EventHandler<Efl.Ui.IPropertyBindPropertyBoundEvt_Args> PropertyBoundEvt
1054     {
1055         add {
1056             lock (eventLock) {
1057                 string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
1058                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_PropertyBoundEvt_delegate)) {
1059                     eventHandlers.AddHandler(PropertyBoundEvtKey , value);
1060                 } else
1061                     Eina.Log.Error($"Error adding proxy for event {key}");
1062             }
1063         }
1064         remove {
1065             lock (eventLock) {
1066                 string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
1067                 if (RemoveNativeEventHandler(key, this.evt_PropertyBoundEvt_delegate)) {
1068                     eventHandlers.RemoveHandler(PropertyBoundEvtKey , value);
1069                 } else
1070                     Eina.Log.Error($"Error removing proxy for event {key}");
1071             }
1072         }
1073     }
1074     ///<summary>Method to raise event PropertyBoundEvt.</summary>
1075     public void On_PropertyBoundEvt(Efl.Ui.IPropertyBindPropertyBoundEvt_Args e)
1076     {
1077         EventHandler<Efl.Ui.IPropertyBindPropertyBoundEvt_Args> evt;
1078         lock (eventLock) {
1079         evt = (EventHandler<Efl.Ui.IPropertyBindPropertyBoundEvt_Args>)eventHandlers[PropertyBoundEvtKey];
1080         }
1081         evt?.Invoke(this, e);
1082     }
1083     Efl.EventCb evt_PropertyBoundEvt_delegate;
1084     private void on_PropertyBoundEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1085     {
1086         Efl.Ui.IPropertyBindPropertyBoundEvt_Args args = new Efl.Ui.IPropertyBindPropertyBoundEvt_Args();
1087       args.arg = Eina.StringConversion.NativeUtf8ToManagedString(evt.Info);
1088         try {
1089             On_PropertyBoundEvt(args);
1090         } catch (Exception e) {
1091             Eina.Log.Error(e.ToString());
1092             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1093         }
1094     }
1095
1096 private static object WmSelectionChangedEvtKey = new object();
1097     /// <summary>Called when display server&apos;s selection has changed</summary>
1098     public event EventHandler<Efl.Ui.ISelectionWmSelectionChangedEvt_Args> WmSelectionChangedEvt
1099     {
1100         add {
1101             lock (eventLock) {
1102                 string key = "_EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED";
1103                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_WmSelectionChangedEvt_delegate)) {
1104                     eventHandlers.AddHandler(WmSelectionChangedEvtKey , value);
1105                 } else
1106                     Eina.Log.Error($"Error adding proxy for event {key}");
1107             }
1108         }
1109         remove {
1110             lock (eventLock) {
1111                 string key = "_EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED";
1112                 if (RemoveNativeEventHandler(key, this.evt_WmSelectionChangedEvt_delegate)) {
1113                     eventHandlers.RemoveHandler(WmSelectionChangedEvtKey , value);
1114                 } else
1115                     Eina.Log.Error($"Error removing proxy for event {key}");
1116             }
1117         }
1118     }
1119     ///<summary>Method to raise event WmSelectionChangedEvt.</summary>
1120     public void On_WmSelectionChangedEvt(Efl.Ui.ISelectionWmSelectionChangedEvt_Args e)
1121     {
1122         EventHandler<Efl.Ui.ISelectionWmSelectionChangedEvt_Args> evt;
1123         lock (eventLock) {
1124         evt = (EventHandler<Efl.Ui.ISelectionWmSelectionChangedEvt_Args>)eventHandlers[WmSelectionChangedEvtKey];
1125         }
1126         evt?.Invoke(this, e);
1127     }
1128     Efl.EventCb evt_WmSelectionChangedEvt_delegate;
1129     private void on_WmSelectionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1130     {
1131         Efl.Ui.ISelectionWmSelectionChangedEvt_Args args = new Efl.Ui.ISelectionWmSelectionChangedEvt_Args();
1132       args.arg =  evt.Info;;
1133         try {
1134             On_WmSelectionChangedEvt(args);
1135         } catch (Exception e) {
1136             Eina.Log.Error(e.ToString());
1137             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1138         }
1139     }
1140
1141 private static object FocusChangedEvtKey = new object();
1142     /// <summary>Emitted if the focus state has changed.
1143     /// (Since EFL 1.22)</summary>
1144     public event EventHandler<Efl.Ui.Focus.IObjectFocusChangedEvt_Args> FocusChangedEvt
1145     {
1146         add {
1147             lock (eventLock) {
1148                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_CHANGED";
1149                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_FocusChangedEvt_delegate)) {
1150                     eventHandlers.AddHandler(FocusChangedEvtKey , value);
1151                 } else
1152                     Eina.Log.Error($"Error adding proxy for event {key}");
1153             }
1154         }
1155         remove {
1156             lock (eventLock) {
1157                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_CHANGED";
1158                 if (RemoveNativeEventHandler(key, this.evt_FocusChangedEvt_delegate)) {
1159                     eventHandlers.RemoveHandler(FocusChangedEvtKey , value);
1160                 } else
1161                     Eina.Log.Error($"Error removing proxy for event {key}");
1162             }
1163         }
1164     }
1165     ///<summary>Method to raise event FocusChangedEvt.</summary>
1166     public void On_FocusChangedEvt(Efl.Ui.Focus.IObjectFocusChangedEvt_Args e)
1167     {
1168         EventHandler<Efl.Ui.Focus.IObjectFocusChangedEvt_Args> evt;
1169         lock (eventLock) {
1170         evt = (EventHandler<Efl.Ui.Focus.IObjectFocusChangedEvt_Args>)eventHandlers[FocusChangedEvtKey];
1171         }
1172         evt?.Invoke(this, e);
1173     }
1174     Efl.EventCb evt_FocusChangedEvt_delegate;
1175     private void on_FocusChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1176     {
1177         Efl.Ui.Focus.IObjectFocusChangedEvt_Args args = new Efl.Ui.Focus.IObjectFocusChangedEvt_Args();
1178       args.arg = evt.Info != IntPtr.Zero;
1179         try {
1180             On_FocusChangedEvt(args);
1181         } catch (Exception e) {
1182             Eina.Log.Error(e.ToString());
1183             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1184         }
1185     }
1186
1187 private static object FocusManagerChangedEvtKey = new object();
1188     /// <summary>Emitted when a new manager is the parent for this object.
1189     /// (Since EFL 1.22)</summary>
1190     public event EventHandler<Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args> FocusManagerChangedEvt
1191     {
1192         add {
1193             lock (eventLock) {
1194                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED";
1195                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_FocusManagerChangedEvt_delegate)) {
1196                     eventHandlers.AddHandler(FocusManagerChangedEvtKey , value);
1197                 } else
1198                     Eina.Log.Error($"Error adding proxy for event {key}");
1199             }
1200         }
1201         remove {
1202             lock (eventLock) {
1203                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_MANAGER_CHANGED";
1204                 if (RemoveNativeEventHandler(key, this.evt_FocusManagerChangedEvt_delegate)) {
1205                     eventHandlers.RemoveHandler(FocusManagerChangedEvtKey , value);
1206                 } else
1207                     Eina.Log.Error($"Error removing proxy for event {key}");
1208             }
1209         }
1210     }
1211     ///<summary>Method to raise event FocusManagerChangedEvt.</summary>
1212     public void On_FocusManagerChangedEvt(Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args e)
1213     {
1214         EventHandler<Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args> evt;
1215         lock (eventLock) {
1216         evt = (EventHandler<Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args>)eventHandlers[FocusManagerChangedEvtKey];
1217         }
1218         evt?.Invoke(this, e);
1219     }
1220     Efl.EventCb evt_FocusManagerChangedEvt_delegate;
1221     private void on_FocusManagerChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1222     {
1223         Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args args = new Efl.Ui.Focus.IObjectFocusManagerChangedEvt_Args();
1224       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IManagerConcrete);
1225         try {
1226             On_FocusManagerChangedEvt(args);
1227         } catch (Exception e) {
1228             Eina.Log.Error(e.ToString());
1229             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1230         }
1231     }
1232
1233 private static object FocusParentChangedEvtKey = new object();
1234     /// <summary>Emitted when a new logical parent should be used.
1235     /// (Since EFL 1.22)</summary>
1236     public event EventHandler<Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args> FocusParentChangedEvt
1237     {
1238         add {
1239             lock (eventLock) {
1240                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_PARENT_CHANGED";
1241                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_FocusParentChangedEvt_delegate)) {
1242                     eventHandlers.AddHandler(FocusParentChangedEvtKey , value);
1243                 } else
1244                     Eina.Log.Error($"Error adding proxy for event {key}");
1245             }
1246         }
1247         remove {
1248             lock (eventLock) {
1249                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_PARENT_CHANGED";
1250                 if (RemoveNativeEventHandler(key, this.evt_FocusParentChangedEvt_delegate)) {
1251                     eventHandlers.RemoveHandler(FocusParentChangedEvtKey , value);
1252                 } else
1253                     Eina.Log.Error($"Error removing proxy for event {key}");
1254             }
1255         }
1256     }
1257     ///<summary>Method to raise event FocusParentChangedEvt.</summary>
1258     public void On_FocusParentChangedEvt(Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args e)
1259     {
1260         EventHandler<Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args> evt;
1261         lock (eventLock) {
1262         evt = (EventHandler<Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args>)eventHandlers[FocusParentChangedEvtKey];
1263         }
1264         evt?.Invoke(this, e);
1265     }
1266     Efl.EventCb evt_FocusParentChangedEvt_delegate;
1267     private void on_FocusParentChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1268     {
1269         Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args args = new Efl.Ui.Focus.IObjectFocusParentChangedEvt_Args();
1270       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IObjectConcrete);
1271         try {
1272             On_FocusParentChangedEvt(args);
1273         } catch (Exception e) {
1274             Eina.Log.Error(e.ToString());
1275             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1276         }
1277     }
1278
1279 private static object ChildFocusChangedEvtKey = new object();
1280     /// <summary>Emitted if child_focus has changed.
1281     /// (Since EFL 1.22)</summary>
1282     public event EventHandler<Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args> ChildFocusChangedEvt
1283     {
1284         add {
1285             lock (eventLock) {
1286                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_CHILD_FOCUS_CHANGED";
1287                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_ChildFocusChangedEvt_delegate)) {
1288                     eventHandlers.AddHandler(ChildFocusChangedEvtKey , value);
1289                 } else
1290                     Eina.Log.Error($"Error adding proxy for event {key}");
1291             }
1292         }
1293         remove {
1294             lock (eventLock) {
1295                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_CHILD_FOCUS_CHANGED";
1296                 if (RemoveNativeEventHandler(key, this.evt_ChildFocusChangedEvt_delegate)) {
1297                     eventHandlers.RemoveHandler(ChildFocusChangedEvtKey , value);
1298                 } else
1299                     Eina.Log.Error($"Error removing proxy for event {key}");
1300             }
1301         }
1302     }
1303     ///<summary>Method to raise event ChildFocusChangedEvt.</summary>
1304     public void On_ChildFocusChangedEvt(Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args e)
1305     {
1306         EventHandler<Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args> evt;
1307         lock (eventLock) {
1308         evt = (EventHandler<Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args>)eventHandlers[ChildFocusChangedEvtKey];
1309         }
1310         evt?.Invoke(this, e);
1311     }
1312     Efl.EventCb evt_ChildFocusChangedEvt_delegate;
1313     private void on_ChildFocusChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1314     {
1315         Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args args = new Efl.Ui.Focus.IObjectChildFocusChangedEvt_Args();
1316       args.arg = evt.Info != IntPtr.Zero;
1317         try {
1318             On_ChildFocusChangedEvt(args);
1319         } catch (Exception e) {
1320             Eina.Log.Error(e.ToString());
1321             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1322         }
1323     }
1324
1325 private static object FocusGeometryChangedEvtKey = new object();
1326     /// <summary>Emitted if focus geometry of this object has changed.
1327     /// (Since EFL 1.22)</summary>
1328     public event EventHandler<Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args> FocusGeometryChangedEvt
1329     {
1330         add {
1331             lock (eventLock) {
1332                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_GEOMETRY_CHANGED";
1333                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_FocusGeometryChangedEvt_delegate)) {
1334                     eventHandlers.AddHandler(FocusGeometryChangedEvtKey , value);
1335                 } else
1336                     Eina.Log.Error($"Error adding proxy for event {key}");
1337             }
1338         }
1339         remove {
1340             lock (eventLock) {
1341                 string key = "_EFL_UI_FOCUS_OBJECT_EVENT_FOCUS_GEOMETRY_CHANGED";
1342                 if (RemoveNativeEventHandler(key, this.evt_FocusGeometryChangedEvt_delegate)) {
1343                     eventHandlers.RemoveHandler(FocusGeometryChangedEvtKey , value);
1344                 } else
1345                     Eina.Log.Error($"Error removing proxy for event {key}");
1346             }
1347         }
1348     }
1349     ///<summary>Method to raise event FocusGeometryChangedEvt.</summary>
1350     public void On_FocusGeometryChangedEvt(Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args e)
1351     {
1352         EventHandler<Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args> evt;
1353         lock (eventLock) {
1354         evt = (EventHandler<Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args>)eventHandlers[FocusGeometryChangedEvtKey];
1355         }
1356         evt?.Invoke(this, e);
1357     }
1358     Efl.EventCb evt_FocusGeometryChangedEvt_delegate;
1359     private void on_FocusGeometryChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
1360     {
1361         Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args args = new Efl.Ui.Focus.IObjectFocusGeometryChangedEvt_Args();
1362       args.arg =  evt.Info;;
1363         try {
1364             On_FocusGeometryChangedEvt(args);
1365         } catch (Exception e) {
1366             Eina.Log.Error(e.ToString());
1367             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1368         }
1369     }
1370
1371     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
1372     protected override void RegisterEventProxies()
1373     {
1374         base.RegisterEventProxies();
1375         evt_AtspiHighlightedEvt_delegate = new Efl.EventCb(on_AtspiHighlightedEvt_NativeCallback);
1376         evt_AtspiUnhighlightedEvt_delegate = new Efl.EventCb(on_AtspiUnhighlightedEvt_NativeCallback);
1377         evt_LanguageChangedEvt_delegate = new Efl.EventCb(on_LanguageChangedEvt_NativeCallback);
1378         evt_AccessChangedEvt_delegate = new Efl.EventCb(on_AccessChangedEvt_NativeCallback);
1379         evt_PropertyChangedEvt_delegate = new Efl.EventCb(on_PropertyChangedEvt_NativeCallback);
1380         evt_ChildrenChangedEvt_delegate = new Efl.EventCb(on_ChildrenChangedEvt_NativeCallback);
1381         evt_StateChangedEvt_delegate = new Efl.EventCb(on_StateChangedEvt_NativeCallback);
1382         evt_BoundsChangedEvt_delegate = new Efl.EventCb(on_BoundsChangedEvt_NativeCallback);
1383         evt_VisibleDataChangedEvt_delegate = new Efl.EventCb(on_VisibleDataChangedEvt_NativeCallback);
1384         evt_ActiveDescendantChangedEvt_delegate = new Efl.EventCb(on_ActiveDescendantChangedEvt_NativeCallback);
1385         evt_AddedEvt_delegate = new Efl.EventCb(on_AddedEvt_NativeCallback);
1386         evt_RemovedEvt_delegate = new Efl.EventCb(on_RemovedEvt_NativeCallback);
1387         evt_MoveOutedEvt_delegate = new Efl.EventCb(on_MoveOutedEvt_NativeCallback);
1388         evt_ReadingStateChangedEvt_delegate = new Efl.EventCb(on_ReadingStateChangedEvt_NativeCallback);
1389         evt_DragAcceptEvt_delegate = new Efl.EventCb(on_DragAcceptEvt_NativeCallback);
1390         evt_DragDoneEvt_delegate = new Efl.EventCb(on_DragDoneEvt_NativeCallback);
1391         evt_DragEnterEvt_delegate = new Efl.EventCb(on_DragEnterEvt_NativeCallback);
1392         evt_DragLeaveEvt_delegate = new Efl.EventCb(on_DragLeaveEvt_NativeCallback);
1393         evt_DragPosEvt_delegate = new Efl.EventCb(on_DragPosEvt_NativeCallback);
1394         evt_DragDropEvt_delegate = new Efl.EventCb(on_DragDropEvt_NativeCallback);
1395         evt_PropertiesChangedEvt_delegate = new Efl.EventCb(on_PropertiesChangedEvt_NativeCallback);
1396         evt_PropertyBoundEvt_delegate = new Efl.EventCb(on_PropertyBoundEvt_NativeCallback);
1397         evt_WmSelectionChangedEvt_delegate = new Efl.EventCb(on_WmSelectionChangedEvt_NativeCallback);
1398         evt_FocusChangedEvt_delegate = new Efl.EventCb(on_FocusChangedEvt_NativeCallback);
1399         evt_FocusManagerChangedEvt_delegate = new Efl.EventCb(on_FocusManagerChangedEvt_NativeCallback);
1400         evt_FocusParentChangedEvt_delegate = new Efl.EventCb(on_FocusParentChangedEvt_NativeCallback);
1401         evt_ChildFocusChangedEvt_delegate = new Efl.EventCb(on_ChildFocusChangedEvt_NativeCallback);
1402         evt_FocusGeometryChangedEvt_delegate = new Efl.EventCb(on_FocusGeometryChangedEvt_NativeCallback);
1403     }
1404     /// <summary>Returns the current cursor name.
1405     /// (Since EFL 1.22)</summary>
1406     /// <returns>The cursor name, defined either by the display system or the theme.</returns>
1407     virtual public System.String GetCursor() {
1408          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1409         Eina.Error.RaiseIfUnhandledException();
1410         return _ret_var;
1411  }
1412     /// <summary>Sets or unsets the current cursor.
1413     /// If <c>cursor</c> is <c>null</c> this function will reset the cursor to the default one.
1414     /// (Since EFL 1.22)</summary>
1415     /// <param name="cursor">The cursor name, defined either by the display system or the theme.</param>
1416     /// <returns><c>true</c> if successful.</returns>
1417     virtual public bool SetCursor( System.String cursor) {
1418                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), cursor);
1419         Eina.Error.RaiseIfUnhandledException();
1420                         return _ret_var;
1421  }
1422     /// <summary>Returns the current cursor style name.
1423     /// (Since EFL 1.22)</summary>
1424     /// <returns>A specific style to use, eg. default, transparent, ....</returns>
1425     virtual public System.String GetCursorStyle() {
1426          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_style_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1427         Eina.Error.RaiseIfUnhandledException();
1428         return _ret_var;
1429  }
1430     /// <summary>Sets a style for the current cursor. Call after <see cref="Efl.Ui.Widget.SetCursor"/>.
1431     /// (Since EFL 1.22)</summary>
1432     /// <param name="style">A specific style to use, eg. default, transparent, ....</param>
1433     /// <returns><c>true</c> if successful.</returns>
1434     virtual public bool SetCursorStyle( System.String style) {
1435                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_style_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), style);
1436         Eina.Error.RaiseIfUnhandledException();
1437                         return _ret_var;
1438  }
1439     /// <summary>Returns the current state of theme cursors search.
1440     /// (Since EFL 1.22)</summary>
1441     /// <returns>Whether to use theme cursors.</returns>
1442     virtual public bool GetCursorThemeSearchEnabled() {
1443          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_theme_search_enabled_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1444         Eina.Error.RaiseIfUnhandledException();
1445         return _ret_var;
1446  }
1447     /// <summary>Enables or disables theme cursors.
1448     /// (Since EFL 1.22)</summary>
1449     /// <param name="allow">Whether to use theme cursors.</param>
1450     /// <returns><c>true</c> if successful.</returns>
1451     virtual public bool SetCursorThemeSearchEnabled( bool allow) {
1452                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_cursor_theme_search_enabled_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), allow);
1453         Eina.Error.RaiseIfUnhandledException();
1454                         return _ret_var;
1455  }
1456     /// <summary>Sets the new resize object for this widget.
1457     /// (Since EFL 1.22)</summary>
1458     /// <param name="sobj">A canvas object (often a <see cref="Efl.Canvas.Layout"/> object).</param>
1459     /// <returns></returns>
1460     virtual public void SetResizeObject( Efl.Canvas.Object sobj) {
1461                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_resize_object_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sobj);
1462         Eina.Error.RaiseIfUnhandledException();
1463                          }
1464     /// <summary>Returns whether the widget is disabled.
1465     /// This will return <c>true</c> if any widget in the parent hierarchy is disabled. Re-enabling that parent may in turn change the disabled state of this widget.
1466     /// (Since EFL 1.22)</summary>
1467     /// <returns><c>true</c> if the widget is disabled.</returns>
1468     virtual public bool GetDisabled() {
1469          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_disabled_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1470         Eina.Error.RaiseIfUnhandledException();
1471         return _ret_var;
1472  }
1473     /// <summary>Enables or disables this widget.
1474     /// Disabling a widget will disable all its children recursively, but only this widget will be marked as disabled internally.
1475     /// (Since EFL 1.22)</summary>
1476     /// <param name="disabled"><c>true</c> if the widget is disabled.</param>
1477     /// <returns></returns>
1478     virtual public void SetDisabled( bool disabled) {
1479                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_disabled_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), disabled);
1480         Eina.Error.RaiseIfUnhandledException();
1481                          }
1482     /// <summary>Returns the current style of a widget.
1483     /// (Since EFL 1.22)</summary>
1484     /// <returns>Name of the style to use. Refer to each widget&apos;s documentation for the available style names, or to the themes in use.</returns>
1485     virtual public System.String GetStyle() {
1486          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_style_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1487         Eina.Error.RaiseIfUnhandledException();
1488         return _ret_var;
1489  }
1490     /// <summary>Can only be called during construction, before finalize.
1491     /// (Since EFL 1.22)</summary>
1492     /// <param name="style">Name of the style to use. Refer to each widget&apos;s documentation for the available style names, or to the themes in use.</param>
1493     /// <returns>Whether the style was successfully applied or not, see the Efl.Ui.Theme.Apply_Error subset of <see cref="Eina.Error"/> for more information.</returns>
1494     virtual public Eina.Error SetStyle( System.String style) {
1495                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_style_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), style);
1496         Eina.Error.RaiseIfUnhandledException();
1497                         return _ret_var;
1498  }
1499     /// <summary>The ability for a widget to be focused.
1500     /// Unfocusable objects do nothing when programmatically focused. The nearest focusable parent object the one really getting focus. Also, when they receive mouse input, they will get the event, but not take away the focus from where it was previously.
1501     ///
1502     /// Note: Objects which are meant to be interacted with by input events are created able to be focused, by default. All the others are not.
1503     ///
1504     /// This property&apos;s default value depends on the widget (eg. a box is not focusable, but a button is).
1505     /// (Since EFL 1.22)</summary>
1506     /// <returns>Whether the object is focusable.</returns>
1507     virtual public bool GetFocusAllow() {
1508          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_allow_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1509         Eina.Error.RaiseIfUnhandledException();
1510         return _ret_var;
1511  }
1512     /// <summary>The ability for a widget to be focused.
1513     /// Unfocusable objects do nothing when programmatically focused. The nearest focusable parent object the one really getting focus. Also, when they receive mouse input, they will get the event, but not take away the focus from where it was previously.
1514     ///
1515     /// Note: Objects which are meant to be interacted with by input events are created able to be focused, by default. All the others are not.
1516     ///
1517     /// This property&apos;s default value depends on the widget (eg. a box is not focusable, but a button is).
1518     /// (Since EFL 1.22)</summary>
1519     /// <param name="can_focus">Whether the object is focusable.</param>
1520     /// <returns></returns>
1521     virtual public void SetFocusAllow( bool can_focus) {
1522                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_allow_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), can_focus);
1523         Eina.Error.RaiseIfUnhandledException();
1524                          }
1525     /// <summary>The internal parent of this widget.
1526     /// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
1527     /// (Since EFL 1.22)</summary>
1528     /// <returns>Widget parent object</returns>
1529     virtual public Efl.Ui.Widget GetWidgetParent() {
1530          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1531         Eina.Error.RaiseIfUnhandledException();
1532         return _ret_var;
1533  }
1534     /// <summary>The internal parent of this widget.
1535     /// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
1536     /// (Since EFL 1.22)</summary>
1537     /// <param name="parent">Widget parent object</param>
1538     /// <returns></returns>
1539     virtual public void SetWidgetParent( Efl.Ui.Widget parent) {
1540                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_parent_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), parent);
1541         Eina.Error.RaiseIfUnhandledException();
1542                          }
1543     /// <summary>Accessibility information.
1544     /// This is a replacement string to be read by the accessibility text-to-speech engine, if accessibility is enabled by configuration. This will take precedence over the default text for this object, which means for instance that the label of a button won&apos;t be read out loud, instead <c>txt</c> will be read out.
1545     /// (Since EFL 1.22)</summary>
1546     /// <returns>Accessibility text description.</returns>
1547     virtual public System.String GetAccessInfo() {
1548          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_access_info_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1549         Eina.Error.RaiseIfUnhandledException();
1550         return _ret_var;
1551  }
1552     /// <summary>Accessibility information.
1553     /// This is a replacement string to be read by the accessibility text-to-speech engine, if accessibility is enabled by configuration. This will take precedence over the default text for this object, which means for instance that the label of a button won&apos;t be read out loud, instead <c>txt</c> will be read out.
1554     /// (Since EFL 1.22)</summary>
1555     /// <param name="txt">Accessibility text description.</param>
1556     /// <returns></returns>
1557     virtual public void SetAccessInfo( System.String txt) {
1558                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_access_info_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), txt);
1559         Eina.Error.RaiseIfUnhandledException();
1560                          }
1561     /// <summary>Region of interest inside this widget, that should be given priority to be visible inside a scroller.
1562     /// When this widget or one of its subwidgets is given focus, this region should be shown, which means any parent scroller should attempt to display the given area of this widget. For instance, an entry given focus should scroll to show the text cursor if that cursor moves. In this example, this region defines the relative geometry of the cursor within the widget.
1563     ///
1564     /// Note: The region is relative to the top-left corner of the widget, i.e. X,Y start from 0,0 to indicate the top-left corner of the widget. W,H must be greater or equal to 1 for this region to be taken into account, otherwise it is ignored.
1565     /// (Since EFL 1.22)</summary>
1566     /// <returns>The relative region to show. If width or height is &lt;= 0 it will be ignored, and no action will be taken.</returns>
1567     virtual public Eina.Rect GetInterestRegion() {
1568          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_interest_region_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1569         Eina.Error.RaiseIfUnhandledException();
1570         return _ret_var;
1571  }
1572     /// <summary>This is a read-only property.
1573     /// (Since EFL 1.22)</summary>
1574     /// <returns>The rectangle area.</returns>
1575     virtual public Eina.Rect GetFocusHighlightGeometry() {
1576          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_highlight_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1577         Eina.Error.RaiseIfUnhandledException();
1578         return _ret_var;
1579  }
1580     /// <summary>Focus order property
1581     /// (Since EFL 1.22)</summary>
1582     /// <returns>FIXME</returns>
1583     virtual public uint GetFocusOrder() {
1584          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_order_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1585         Eina.Error.RaiseIfUnhandledException();
1586         return _ret_var;
1587  }
1588     /// <summary>A custom chain of objects to pass focus.
1589     /// Note: On focus cycle, only will be evaluated children of this container.
1590     /// (Since EFL 1.22)</summary>
1591     /// <returns>Chain of objects</returns>
1592     virtual public Eina.List<Efl.Canvas.Object> GetFocusCustomChain() {
1593          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_custom_chain_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1594         Eina.Error.RaiseIfUnhandledException();
1595         return new Eina.List<Efl.Canvas.Object>(_ret_var, false, false);
1596  }
1597     /// <summary>This function overwrites any previous custom focus chain within the list of objects. The previous list will be deleted and this list will be managed by elementary. After it is set, don&apos;t modify it.
1598     /// (Since EFL 1.22)</summary>
1599     /// <param name="objs">Chain of objects to pass focus</param>
1600     /// <returns></returns>
1601     virtual public void SetFocusCustomChain( Eina.List<Efl.Canvas.Object> objs) {
1602          var _in_objs = objs.Handle;
1603                         Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_custom_chain_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_objs);
1604         Eina.Error.RaiseIfUnhandledException();
1605                          }
1606     /// <summary>Current focused object in object tree.
1607     /// (Since EFL 1.22)</summary>
1608     /// <returns>Current focused or <c>null</c>, if there is no focused object.</returns>
1609     virtual public Efl.Canvas.Object GetFocusedObject() {
1610          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focused_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1611         Eina.Error.RaiseIfUnhandledException();
1612         return _ret_var;
1613  }
1614     /// <summary>The widget&apos;s focus move policy.
1615     /// (Since EFL 1.22)</summary>
1616     /// <returns>Focus move policy</returns>
1617     virtual public Efl.Ui.Focus.MovePolicy GetFocusMovePolicy() {
1618          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_move_policy_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1619         Eina.Error.RaiseIfUnhandledException();
1620         return _ret_var;
1621  }
1622     /// <summary>The widget&apos;s focus move policy.
1623     /// (Since EFL 1.22)</summary>
1624     /// <param name="policy">Focus move policy</param>
1625     /// <returns></returns>
1626     virtual public void SetFocusMovePolicy( Efl.Ui.Focus.MovePolicy policy) {
1627                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_move_policy_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), policy);
1628         Eina.Error.RaiseIfUnhandledException();
1629                          }
1630     /// <summary>Control the widget&apos;s focus_move_policy mode setting.
1631     /// (Since EFL 1.22)</summary>
1632     /// <returns><c>true</c> to follow system focus move policy change, <c>false</c> otherwise</returns>
1633     virtual public bool GetFocusMovePolicyAutomatic() {
1634          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_move_policy_automatic_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1635         Eina.Error.RaiseIfUnhandledException();
1636         return _ret_var;
1637  }
1638     /// <summary>Control the widget&apos;s focus_move_policy mode setting.
1639     /// (Since EFL 1.22)</summary>
1640     /// <param name="automatic"><c>true</c> to follow system focus move policy change, <c>false</c> otherwise</param>
1641     /// <returns></returns>
1642     virtual public void SetFocusMovePolicyAutomatic( bool automatic) {
1643                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_move_policy_automatic_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), automatic);
1644         Eina.Error.RaiseIfUnhandledException();
1645                          }
1646     /// <summary>Virtual function handling input events on the widget.
1647     /// This method should return <c>true</c> if the event has been processed. Only key down, key up and pointer wheel events will be propagated through this function.
1648     ///
1649     /// It is common for the event to be also marked as processed as in <see cref="Efl.Input.IEvent.Processed"/>, if this operation was successful. This makes sure other widgets will not also process this input event.
1650     /// (Since EFL 1.22)</summary>
1651     /// <param name="eo_event">EO event struct with an Efl.Input.Event as info.</param>
1652     /// <param name="source">Source object where the event originated. Often same as this.</param>
1653     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1654     virtual public bool WidgetInputEventHandler( ref Efl.Event eo_event,  Efl.Canvas.Object source) {
1655          Efl.Event.NativeStruct _in_eo_event = eo_event;
1656                                                 var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_input_event_handler_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ref _in_eo_event,  source);
1657         Eina.Error.RaiseIfUnhandledException();
1658                         eo_event = _in_eo_event;
1659                 return _ret_var;
1660  }
1661     /// <summary>Hook function called when widget is activated through accessibility.
1662     /// This meant to be overridden by subclasses to support accessibility. This is an unstable API.
1663     /// (Since EFL 1.22)</summary>
1664     /// <param name="act">Type of activation.</param>
1665     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1666     virtual public bool OnAccessActivate( Efl.Ui.Activate act) {
1667                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_on_access_activate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), act);
1668         Eina.Error.RaiseIfUnhandledException();
1669                         return _ret_var;
1670  }
1671     /// <summary>Hook function called when accessibility is changed on the widget.
1672     /// This meant to be overridden by subclasses to support accessibility. This is an unstable API.
1673     /// (Since EFL 1.22)</summary>
1674     /// <param name="enable"><c>true</c> if accessibility is enabled.</param>
1675     /// <returns></returns>
1676     virtual public void UpdateOnAccess( bool enable) {
1677                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_on_access_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), enable);
1678         Eina.Error.RaiseIfUnhandledException();
1679                          }
1680     /// <summary>&apos;Virtual&apos; function on the widget being set screen reader.
1681     /// (Since EFL 1.22)</summary>
1682     /// <param name="is_screen_reader"></param>
1683     /// <returns></returns>
1684     virtual public void ScreenReader( bool is_screen_reader) {
1685                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_screen_reader_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), is_screen_reader);
1686         Eina.Error.RaiseIfUnhandledException();
1687                          }
1688     /// <summary>&apos;Virtual&apos; function on the widget being set atspi.
1689     /// (Since EFL 1.22)</summary>
1690     /// <param name="is_atspi"></param>
1691     /// <returns></returns>
1692     virtual public void Atspi( bool is_atspi) {
1693                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_atspi_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), is_atspi);
1694         Eina.Error.RaiseIfUnhandledException();
1695                          }
1696     /// <summary>Virtual function customizing sub objects being added.
1697     /// When a widget is added as a sub-object of another widget (like list elements inside a list container, for example) some of its properties are automatically adapted to the parent&apos;s current values (like focus, access, theme, scale, mirror, scrollable child get, translate, display mode set, tree dump). Override this method if you want to customize differently sub-objects being added to this object.
1698     ///
1699     /// Sub objects can be any canvas object, not necessarily widgets.
1700     ///
1701     /// See also <see cref="Efl.Ui.Widget.WidgetParent"/>.
1702     /// (Since EFL 1.22)</summary>
1703     /// <param name="sub_obj">Sub object to be added. Not necessarily a widget itself.</param>
1704     /// <returns>Indicates if the operation succeeded.</returns>
1705     virtual public bool AddWidgetSubObject( Efl.Canvas.Object sub_obj) {
1706                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_sub_object_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sub_obj);
1707         Eina.Error.RaiseIfUnhandledException();
1708                         return _ret_var;
1709  }
1710     /// <summary>Virtual function customizing sub objects being removed.
1711     /// When a widget is removed as a sub-object from another widget (<see cref="Efl.IPack.Unpack"/>, <see cref="Efl.IContent.UnsetContent"/>, for example) some of its properties are automatically adjusted.(like focus, access, tree dump) Override this method if you want to customize differently sub-objects being removed to this object.
1712     ///
1713     /// Sub objects can be any canvas object, not necessarily widgets.
1714     ///
1715     /// See also <see cref="Efl.Ui.Widget.WidgetParent"/> and <see cref="Efl.Ui.Widget.AddWidgetSubObject"/>.
1716     /// (Since EFL 1.22)</summary>
1717     /// <param name="sub_obj">Sub object to be removed. Should be a child of this widget.</param>
1718     /// <returns>Indicates if the operation succeeded.</returns>
1719     virtual public bool DelWidgetSubObject( Efl.Canvas.Object sub_obj) {
1720                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_sub_object_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), sub_obj);
1721         Eina.Error.RaiseIfUnhandledException();
1722                         return _ret_var;
1723  }
1724     /// <summary>Virtual function called when the widget needs to re-apply its theme.
1725     /// This may be called when the object is first created, or whenever the widget is modified in any way that may require a reload of the theme. This may include but is not limited to scale, theme, or mirrored mode changes.
1726     ///
1727     /// Note: even widgets not based on layouts may override this method to handle widget updates (scale, mirrored mode, etc...).
1728     /// (Since EFL 1.22)</summary>
1729     /// <returns>Indicates success, and if the current theme or default theme was used.</returns>
1730     virtual public Eina.Error ThemeApply() {
1731          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_theme_apply_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1732         Eina.Error.RaiseIfUnhandledException();
1733         return _ret_var;
1734  }
1735     /// <summary>Push scroll hold
1736     /// (Since EFL 1.22)</summary>
1737     /// <returns></returns>
1738     virtual public void PushScrollHold() {
1739          Efl.Ui.WidgetNativeInherit.efl_ui_widget_scroll_hold_push_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1740         Eina.Error.RaiseIfUnhandledException();
1741          }
1742     /// <summary>Pop scroller hold
1743     /// (Since EFL 1.22)</summary>
1744     /// <returns></returns>
1745     virtual public void PopScrollHold() {
1746          Efl.Ui.WidgetNativeInherit.efl_ui_widget_scroll_hold_pop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1747         Eina.Error.RaiseIfUnhandledException();
1748          }
1749     /// <summary>Push scroller freeze
1750     /// (Since EFL 1.22)</summary>
1751     /// <returns></returns>
1752     virtual public void PushScrollFreeze() {
1753          Efl.Ui.WidgetNativeInherit.efl_ui_widget_scroll_freeze_push_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1754         Eina.Error.RaiseIfUnhandledException();
1755          }
1756     /// <summary>Pop scroller freeze
1757     /// (Since EFL 1.22)</summary>
1758     /// <returns></returns>
1759     virtual public void PopScrollFreeze() {
1760          Efl.Ui.WidgetNativeInherit.efl_ui_widget_scroll_freeze_pop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1761         Eina.Error.RaiseIfUnhandledException();
1762          }
1763     /// <summary>Get the access object of given part of the widget.
1764     /// (Since EFL 1.18)</summary>
1765     /// <param name="part">The object&apos;s part name to get access object</param>
1766     /// <returns></returns>
1767     virtual public Efl.Canvas.Object GetPartAccessObject( System.String part) {
1768                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_part_access_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), part);
1769         Eina.Error.RaiseIfUnhandledException();
1770                         return _ret_var;
1771  }
1772     /// <summary>Get newest focus in order
1773     /// (Since EFL 1.22)</summary>
1774     /// <param name="newest_focus_order">Newest focus order</param>
1775     /// <param name="can_focus_only"><c>true</c> only us widgets which can focus, <c>false</c> otherweise</param>
1776     /// <returns>Handle to focused widget</returns>
1777     virtual public Efl.Canvas.Object GetNewestFocusOrder( out uint newest_focus_order,  bool can_focus_only) {
1778                                                          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_newest_focus_order_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out newest_focus_order,  can_focus_only);
1779         Eina.Error.RaiseIfUnhandledException();
1780                                         return _ret_var;
1781  }
1782     /// <summary>Set the next object with specific focus direction.
1783     /// (Since EFL 1.8)</summary>
1784     /// <param name="next">Focus next object</param>
1785     /// <param name="dir">Focus direction</param>
1786     /// <returns></returns>
1787     virtual public void SetFocusNextObject( Efl.Canvas.Object next,  Efl.Ui.Focus.Direction dir) {
1788                                                          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_object_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), next,  dir);
1789         Eina.Error.RaiseIfUnhandledException();
1790                                          }
1791     /// <summary>Get the next object with specific focus direction.
1792     /// (Since EFL 1.8)</summary>
1793     /// <param name="dir">Focus direction</param>
1794     /// <returns>Focus next object</returns>
1795     virtual public Efl.Canvas.Object GetFocusNextObject( Efl.Ui.Focus.Direction dir) {
1796                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
1797         Eina.Error.RaiseIfUnhandledException();
1798                         return _ret_var;
1799  }
1800     /// <summary>Set the next object item with specific focus direction.
1801     /// (Since EFL 1.16)</summary>
1802     /// <param name="next_item">Focus next object item</param>
1803     /// <param name="dir">Focus direction</param>
1804     /// <returns></returns>
1805     virtual public void SetFocusNextItem( Efl.Ui.Widget next_item,  Efl.Ui.Focus.Direction dir) {
1806                                                          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_item_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), next_item,  dir);
1807         Eina.Error.RaiseIfUnhandledException();
1808                                          }
1809     /// <summary>Get the next object item with specific focus direction.
1810     /// (Since EFL 1.16)</summary>
1811     /// <param name="dir">Focus direction</param>
1812     /// <returns>Focus next object item</returns>
1813     virtual public Efl.Ui.Widget GetFocusNextItem( Efl.Ui.Focus.Direction dir) {
1814                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_item_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
1815         Eina.Error.RaiseIfUnhandledException();
1816                         return _ret_var;
1817  }
1818     /// <summary>Handle focus tree unfocusable
1819     /// (Since EFL 1.22)</summary>
1820     /// <returns></returns>
1821     virtual public void FocusTreeUnfocusableHandle() {
1822          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_tree_unfocusable_handle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1823         Eina.Error.RaiseIfUnhandledException();
1824          }
1825     /// <summary>Prepend object to custom focus chain.
1826     /// Note: If @&quot;relative_child&quot; equal to <c>null</c> or not in custom chain, the object will be added in begin.
1827     ///
1828     /// Note: On focus cycle, only will be evaluated children of this container.
1829     /// (Since EFL 1.22)</summary>
1830     /// <param name="child">The child to be added in custom chain.</param>
1831     /// <param name="relative_child">The relative object to position the child.</param>
1832     /// <returns></returns>
1833     virtual public void FocusCustomChainPrepend( Efl.Canvas.Object child,  Efl.Canvas.Object relative_child) {
1834                                                          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_custom_chain_prepend_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  relative_child);
1835         Eina.Error.RaiseIfUnhandledException();
1836                                          }
1837     /// <summary>Give focus to next object with specific focus direction in object tree.
1838     /// (Since EFL 1.22)</summary>
1839     /// <param name="dir">Direction to move the focus.</param>
1840     /// <returns></returns>
1841     virtual public void FocusCycle( Efl.Ui.Focus.Direction dir) {
1842                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_cycle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
1843         Eina.Error.RaiseIfUnhandledException();
1844                          }
1845     /// <summary>&apos;Virtual&apos; function handling passing focus to sub-objects given a direction, in degrees.
1846     /// (Since EFL 1.22)</summary>
1847     /// <param name="kw_base">Base object</param>
1848     /// <param name="degree">Degree</param>
1849     /// <param name="direction">Direction</param>
1850     /// <param name="direction_item">Direction item</param>
1851     /// <param name="weight">Weight</param>
1852     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1853     virtual public bool FocusDirection( Efl.Canvas.Object kw_base,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight) {
1854                                                                                                                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_direction_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), kw_base,  degree,  out direction,  out direction_item,  out weight);
1855         Eina.Error.RaiseIfUnhandledException();
1856                                                                                         return _ret_var;
1857  }
1858     /// <summary>&apos;Virtual&apos; function which checks if handling of passing focus to sub-objects is supported by widget.
1859     /// (Since EFL 1.22)</summary>
1860     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1861     virtual public bool IsFocusNextManager() {
1862          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_manager_is_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1863         Eina.Error.RaiseIfUnhandledException();
1864         return _ret_var;
1865  }
1866     /// <summary>Get focus list direction
1867     /// (Since EFL 1.22)</summary>
1868     /// <param name="kw_base">Base object</param>
1869     /// <param name="items">Item list</param>
1870     /// <param name="list_data_get">Data get function</param>
1871     /// <param name="degree">Degree</param>
1872     /// <param name="direction">Direction</param>
1873     /// <param name="direction_item">Direction item</param>
1874     /// <param name="weight">Weight</param>
1875     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1876     virtual public bool GetFocusListDirection( Efl.Canvas.Object kw_base,  Eina.List<Efl.Object> items,  System.IntPtr list_data_get,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight) {
1877                  var _in_items = items.Handle;
1878                                                                                                                                                                 var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_list_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), kw_base,  _in_items,  list_data_get,  degree,  out direction,  out direction_item,  out weight);
1879         Eina.Error.RaiseIfUnhandledException();
1880                                                                                                                         return _ret_var;
1881  }
1882     /// <summary>Clear focused object
1883     /// (Since EFL 1.22)</summary>
1884     /// <returns></returns>
1885     virtual public void ClearFocusedObject() {
1886          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focused_object_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1887         Eina.Error.RaiseIfUnhandledException();
1888          }
1889     /// <summary>Go in focus direction
1890     /// (Since EFL 1.22)</summary>
1891     /// <param name="degree">Degree</param>
1892     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1893     virtual public bool FocusDirectionGo( double degree) {
1894                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_direction_go_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), degree);
1895         Eina.Error.RaiseIfUnhandledException();
1896                         return _ret_var;
1897  }
1898     /// <summary>Get next focus item
1899     /// (Since EFL 1.22)</summary>
1900     /// <param name="dir">Focus direction</param>
1901     /// <param name="next">Next object</param>
1902     /// <param name="next_item">Next item</param>
1903     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1904     virtual public bool GetFocusNext( Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item) {
1905                                                                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir,  out next,  out next_item);
1906         Eina.Error.RaiseIfUnhandledException();
1907                                                         return _ret_var;
1908  }
1909     /// <summary>Restore the focus state of the sub-tree.
1910     /// This API will restore the focus state of the sub-tree to the latest state. If a sub-tree is unfocused and wants to get back to the latest focus state, this API will be helpful.
1911     /// (Since EFL 1.22)</summary>
1912     /// <returns></returns>
1913     virtual public void FocusRestore() {
1914          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_restore_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1915         Eina.Error.RaiseIfUnhandledException();
1916          }
1917     /// <summary>Unset a custom focus chain on a given Elementary widget.
1918     /// Any focus chain previously set is removed entirely after this call.
1919     /// (Since EFL 1.22)</summary>
1920     /// <returns></returns>
1921     virtual public void UnsetFocusCustomChain() {
1922          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_custom_chain_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1923         Eina.Error.RaiseIfUnhandledException();
1924          }
1925     /// <summary>Steal focus
1926     /// (Since EFL 1.22)</summary>
1927     /// <param name="item">Widget to steal focus from</param>
1928     /// <returns></returns>
1929     virtual public void FocusSteal( Efl.Ui.Widget item) {
1930                                  Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_steal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), item);
1931         Eina.Error.RaiseIfUnhandledException();
1932                          }
1933     /// <summary>Handle hide focus
1934     /// (Since EFL 1.22)</summary>
1935     /// <returns></returns>
1936     virtual public void FocusHideHandle() {
1937          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_hide_handle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1938         Eina.Error.RaiseIfUnhandledException();
1939          }
1940     /// <summary>&apos;Virtual&apos; function handling passing focus to sub-objects.
1941     /// (Since EFL 1.22)</summary>
1942     /// <param name="dir">Focus direction</param>
1943     /// <param name="next">Next object</param>
1944     /// <param name="next_item">Next item</param>
1945     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1946     virtual public bool FocusNext( Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item) {
1947                                                                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir,  out next,  out next_item);
1948         Eina.Error.RaiseIfUnhandledException();
1949                                                         return _ret_var;
1950  }
1951     /// <summary>Get next item in focus list
1952     /// (Since EFL 1.22)</summary>
1953     /// <param name="items">Item list</param>
1954     /// <param name="list_data_get">Function type</param>
1955     /// <param name="dir">Focus direction</param>
1956     /// <param name="next">Next object</param>
1957     /// <param name="next_item">Next item</param>
1958     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1959     virtual public bool GetFocusListNext( Eina.List<Efl.Object> items,  System.IntPtr list_data_get,  Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item) {
1960          var _in_items = items.Handle;
1961                                                                                                                         var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_list_next_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_items,  list_data_get,  dir,  out next,  out next_item);
1962         Eina.Error.RaiseIfUnhandledException();
1963                                                                                         return _ret_var;
1964  }
1965     /// <summary>Handle focus mouse up
1966     /// (Since EFL 1.22)</summary>
1967     /// <returns></returns>
1968     virtual public void FocusMouseUpHandle() {
1969          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_mouse_up_handle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1970         Eina.Error.RaiseIfUnhandledException();
1971          }
1972     /// <summary>Get focus direction
1973     /// (Since EFL 1.22)</summary>
1974     /// <param name="kw_base">Base</param>
1975     /// <param name="degree">Degree</param>
1976     /// <param name="direction">Direction</param>
1977     /// <param name="direction_item">Direction item</param>
1978     /// <param name="weight">Weight</param>
1979     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1980     virtual public bool GetFocusDirection( Efl.Canvas.Object kw_base,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight) {
1981                                                                                                                                  var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), kw_base,  degree,  out direction,  out direction_item,  out weight);
1982         Eina.Error.RaiseIfUnhandledException();
1983                                                                                         return _ret_var;
1984  }
1985     /// <summary>Handle disable widget focus
1986     /// (Since EFL 1.22)</summary>
1987     /// <returns></returns>
1988     virtual public void FocusDisabledHandle() {
1989          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_disabled_handle_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1990         Eina.Error.RaiseIfUnhandledException();
1991          }
1992     /// <summary>Append object to custom focus chain.
1993     /// Note: If @&quot;relative_child&quot; equal to <c>null</c> or not in custom chain, the object will be added in end.
1994     ///
1995     /// Note: On focus cycle, only will be evaluated children of this container.
1996     /// (Since EFL 1.22)</summary>
1997     /// <param name="child">The child to be added in custom chain.</param>
1998     /// <param name="relative_child">The relative object to position the child.</param>
1999     /// <returns></returns>
2000     virtual public void AppendFocusCustomChain( Efl.Canvas.Object child,  Efl.Canvas.Object relative_child) {
2001                                                          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_custom_chain_append_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child,  relative_child);
2002         Eina.Error.RaiseIfUnhandledException();
2003                                          }
2004     /// <summary>No description supplied.
2005     /// (Since EFL 1.18)</summary>
2006     /// <returns></returns>
2007     virtual public void FocusReconfigure() {
2008          Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_reconfigure_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2009         Eina.Error.RaiseIfUnhandledException();
2010          }
2011     /// <summary>Virtual function which checks if this widget can handle passing focus to sub-object, in a given direction.
2012     /// (Since EFL 1.22)</summary>
2013     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
2014     virtual public bool IsFocusDirectionManager() {
2015          var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_direction_manager_is_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2016         Eina.Error.RaiseIfUnhandledException();
2017         return _ret_var;
2018  }
2019     /// <summary>Apply a new focus state on the widget.
2020     /// This method is called internally by <see cref="Efl.Ui.Widget"/>. Override it to change how a widget interacts with its focus manager. If a widget desires to change the applied configuration, it has to modify <c>configured_state</c> in addition to any internal changes.
2021     ///
2022     /// The default implementation (when this method is not overridden) applies <c>configured_state</c> using the <c>manager</c> contained inside.
2023     /// (Since EFL 1.22)</summary>
2024     /// <param name="current_state">The current focus configuration of the widget.</param>
2025     /// <param name="configured_state">The new configuration being set on the widget.</param>
2026     /// <param name="redirect">A redirect object if there is any</param>
2027     /// <returns>Returns <c>true</c> if the widget is registered in the focus manager, <c>false</c> if not.</returns>
2028     virtual public bool FocusStateApply( Efl.Ui.WidgetFocusState current_state,  ref Efl.Ui.WidgetFocusState configured_state,  Efl.Ui.Widget redirect) {
2029          Efl.Ui.WidgetFocusState.NativeStruct _in_current_state = current_state;
2030                                 var _out_configured_state = new Efl.Ui.WidgetFocusState.NativeStruct();
2031                                         var _ret_var = Efl.Ui.WidgetNativeInherit.efl_ui_widget_focus_state_apply_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_current_state,  ref _out_configured_state,  redirect);
2032         Eina.Error.RaiseIfUnhandledException();
2033                 configured_state = _out_configured_state;
2034                                         return _ret_var;
2035  }
2036     /// <summary>Get a proxy object referring to a part of an object.
2037     /// (Since EFL 1.22)</summary>
2038     /// <param name="name">The part name.</param>
2039     /// <returns>A (proxy) object, valid for a single call.</returns>
2040     virtual public Efl.Object GetPart( System.String name) {
2041                                  var _ret_var = Efl.IPartNativeInherit.efl_part_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name);
2042         Eina.Error.RaiseIfUnhandledException();
2043                         return _ret_var;
2044  }
2045     /// <summary>Gets action name for given id</summary>
2046     /// <param name="id">ID to get action name for</param>
2047     /// <returns>Action name</returns>
2048     virtual public System.String GetActionName( int id) {
2049                                  var _ret_var = Efl.Access.IActionNativeInherit.efl_access_action_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id);
2050         Eina.Error.RaiseIfUnhandledException();
2051                         return _ret_var;
2052  }
2053     /// <summary>Gets localized action name for given id</summary>
2054     /// <param name="id">ID to get localized name for</param>
2055     /// <returns>Localized name</returns>
2056     virtual public System.String GetActionLocalizedName( int id) {
2057                                  var _ret_var = Efl.Access.IActionNativeInherit.efl_access_action_localized_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id);
2058         Eina.Error.RaiseIfUnhandledException();
2059                         return _ret_var;
2060  }
2061     /// <summary>Get list of available widget actions</summary>
2062     /// <returns>Contains statically allocated strings.</returns>
2063     virtual public Eina.List<Efl.Access.ActionData> GetActions() {
2064          var _ret_var = Efl.Access.IActionNativeInherit.efl_access_action_actions_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2065         Eina.Error.RaiseIfUnhandledException();
2066         return new Eina.List<Efl.Access.ActionData>(_ret_var, false, false);
2067  }
2068     /// <summary>Performs action on given widget.</summary>
2069     /// <param name="id">ID for widget</param>
2070     /// <returns><c>true</c> if action was performed, <c>false</c> otherwise</returns>
2071     virtual public bool ActionDo( int id) {
2072                                  var _ret_var = Efl.Access.IActionNativeInherit.efl_access_action_do_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id);
2073         Eina.Error.RaiseIfUnhandledException();
2074                         return _ret_var;
2075  }
2076     /// <summary>Gets configured keybinding for specific action and widget.</summary>
2077     /// <param name="id">ID for widget</param>
2078     /// <returns>Should be freed by the user.</returns>
2079     virtual public System.String GetActionKeybinding( int id) {
2080                                  var _ret_var = Efl.Access.IActionNativeInherit.efl_access_action_keybinding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id);
2081         Eina.Error.RaiseIfUnhandledException();
2082                         return _ret_var;
2083  }
2084     /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
2085     /// <returns>Z order of component</returns>
2086     virtual public int GetZOrder() {
2087          var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_z_order_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2088         Eina.Error.RaiseIfUnhandledException();
2089         return _ret_var;
2090  }
2091     /// <summary>Geometry of accessible widget.</summary>
2092     /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
2093     /// <returns>The geometry.</returns>
2094     virtual public Eina.Rect GetExtents( bool screen_coords) {
2095                                  var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_extents_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), screen_coords);
2096         Eina.Error.RaiseIfUnhandledException();
2097                         return _ret_var;
2098  }
2099     /// <summary>Geometry of accessible widget.</summary>
2100     /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
2101     /// <param name="rect">The geometry.</param>
2102     /// <returns><c>true</c> if geometry was set, <c>false</c> otherwise</returns>
2103     virtual public bool SetExtents( bool screen_coords,  Eina.Rect rect) {
2104                  Eina.Rect.NativeStruct _in_rect = rect;
2105                                         var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_extents_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), screen_coords,  _in_rect);
2106         Eina.Error.RaiseIfUnhandledException();
2107                                         return _ret_var;
2108  }
2109     /// <summary>Position of accessible widget.</summary>
2110     /// <param name="x">X coordinate</param>
2111     /// <param name="y">Y coordinate</param>
2112     /// <returns></returns>
2113     virtual public void GetScreenPosition( out int x,  out int y) {
2114                                                          Efl.Access.IComponentNativeInherit.efl_access_component_screen_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
2115         Eina.Error.RaiseIfUnhandledException();
2116                                          }
2117     /// <summary>Position of accessible widget.</summary>
2118     /// <param name="x">X coordinate</param>
2119     /// <param name="y">Y coordinate</param>
2120     /// <returns><c>true</c> if position was set, <c>false</c> otherwise</returns>
2121     virtual public bool SetScreenPosition( int x,  int y) {
2122                                                          var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_screen_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
2123         Eina.Error.RaiseIfUnhandledException();
2124                                         return _ret_var;
2125  }
2126     /// <summary>Gets position of socket offset.</summary>
2127     /// <param name="x"></param>
2128     /// <param name="y"></param>
2129     /// <returns></returns>
2130     virtual public void GetSocketOffset( out int x,  out int y) {
2131                                                          Efl.Access.IComponentNativeInherit.efl_access_component_socket_offset_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
2132         Eina.Error.RaiseIfUnhandledException();
2133                                          }
2134     /// <summary>Sets position of socket offset.</summary>
2135     /// <param name="x"></param>
2136     /// <param name="y"></param>
2137     /// <returns></returns>
2138     virtual public void SetSocketOffset( int x,  int y) {
2139                                                          Efl.Access.IComponentNativeInherit.efl_access_component_socket_offset_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
2140         Eina.Error.RaiseIfUnhandledException();
2141                                          }
2142     /// <summary>Contains accessible widget</summary>
2143     /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
2144     /// <param name="x">X coordinate</param>
2145     /// <param name="y">Y coordinate</param>
2146     /// <returns><c>true</c> if params have been set, <c>false</c> otherwise</returns>
2147     virtual public bool Contains( bool screen_coords,  int x,  int y) {
2148                                                                                  var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_contains_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), screen_coords,  x,  y);
2149         Eina.Error.RaiseIfUnhandledException();
2150                                                         return _ret_var;
2151  }
2152     /// <summary>Focuses accessible widget.</summary>
2153     /// <returns><c>true</c> if focus grab focus succeed, <c>false</c> otherwise.</returns>
2154     virtual public bool GrabFocus() {
2155          var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_focus_grab_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2156         Eina.Error.RaiseIfUnhandledException();
2157         return _ret_var;
2158  }
2159     /// <summary>Gets top component object occupying space at given coordinates.</summary>
2160     /// <param name="screen_coords">If <c>true</c> x and y values will be relative to screen origin, otherwise relative to canvas</param>
2161     /// <param name="x">X coordinate</param>
2162     /// <param name="y">Y coordinate</param>
2163     /// <returns>Top component object at given coordinate</returns>
2164     virtual public Efl.Object GetAccessibleAtPoint( bool screen_coords,  int x,  int y) {
2165                                                                                  var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_accessible_at_point_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), screen_coords,  x,  y);
2166         Eina.Error.RaiseIfUnhandledException();
2167                                                         return _ret_var;
2168  }
2169     /// <summary>Highlights accessible widget. returns true if highlight grab has successed, false otherwise.
2170     /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
2171     /// <returns></returns>
2172     virtual public bool GrabHighlight() {
2173          var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_highlight_grab_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2174         Eina.Error.RaiseIfUnhandledException();
2175         return _ret_var;
2176  }
2177     /// <summary>Clears highlight of accessible widget. returns true if clear has successed, false otherwise.
2178     /// @if MOBILE @since_tizen 4.0 @elseif WEARABLE @since_tizen 3.0 @endif</summary>
2179     /// <returns></returns>
2180     virtual public bool ClearHighlight() {
2181          var _ret_var = Efl.Access.IComponentNativeInherit.efl_access_component_highlight_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2182         Eina.Error.RaiseIfUnhandledException();
2183         return _ret_var;
2184  }
2185     /// <summary>Gets an localized string describing accessible object role name.</summary>
2186     /// <returns>Localized accessible object role name</returns>
2187     virtual public System.String GetLocalizedRoleName() {
2188          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_localized_role_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2189         Eina.Error.RaiseIfUnhandledException();
2190         return _ret_var;
2191  }
2192     /// <summary>Accessible name of the object.</summary>
2193     /// <returns>Accessible name</returns>
2194     virtual public System.String GetI18nName() {
2195          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_i18n_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2196         Eina.Error.RaiseIfUnhandledException();
2197         return _ret_var;
2198  }
2199     /// <summary>Accessible name of the object.</summary>
2200     /// <param name="i18n_name">Accessible name</param>
2201     /// <returns></returns>
2202     virtual public void SetI18nName( System.String i18n_name) {
2203                                  Efl.Access.IObjectNativeInherit.efl_access_object_i18n_name_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), i18n_name);
2204         Eina.Error.RaiseIfUnhandledException();
2205                          }
2206     /// <summary>Sets name information callback about widget.
2207     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2208     /// <param name="name_cb">reading information callback</param>
2209     /// <param name="data"></param>
2210     /// <returns></returns>
2211     virtual public void SetNameCb( Efl.Access.ReadingInfoCb name_cb,  System.IntPtr data) {
2212                                                          Efl.Access.IObjectNativeInherit.efl_access_object_name_cb_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name_cb,  data);
2213         Eina.Error.RaiseIfUnhandledException();
2214                                          }
2215     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
2216     /// <returns>Accessible relation set</returns>
2217     virtual public Efl.Access.RelationSet GetRelationSet() {
2218          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_relation_set_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2219         Eina.Error.RaiseIfUnhandledException();
2220         return _ret_var;
2221  }
2222     /// <summary>The role of the object in accessibility domain.</summary>
2223     /// <returns>Accessible role</returns>
2224     virtual public Efl.Access.Role GetRole() {
2225          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_role_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2226         Eina.Error.RaiseIfUnhandledException();
2227         return _ret_var;
2228  }
2229     /// <summary>Sets the role of the object in accessibility domain.</summary>
2230     /// <param name="role">Accessible role</param>
2231     /// <returns></returns>
2232     virtual public void SetRole( Efl.Access.Role role) {
2233                                  Efl.Access.IObjectNativeInherit.efl_access_object_role_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), role);
2234         Eina.Error.RaiseIfUnhandledException();
2235                          }
2236     /// <summary>Gets object&apos;s accessible parent.</summary>
2237     /// <returns>Accessible parent</returns>
2238     virtual public Efl.Access.IObject GetAccessParent() {
2239          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_access_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2240         Eina.Error.RaiseIfUnhandledException();
2241         return _ret_var;
2242  }
2243     /// <summary>Gets object&apos;s accessible parent.</summary>
2244     /// <param name="parent">Accessible parent</param>
2245     /// <returns></returns>
2246     virtual public void SetAccessParent( Efl.Access.IObject parent) {
2247                                  Efl.Access.IObjectNativeInherit.efl_access_object_access_parent_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), parent);
2248         Eina.Error.RaiseIfUnhandledException();
2249                          }
2250     /// <summary>Sets contextual information callback about widget.
2251     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2252     /// <param name="description_cb">The function called to provide the accessible description.</param>
2253     /// <param name="data">The data passed to @c description_cb.</param>
2254     /// <returns></returns>
2255     virtual public void SetDescriptionCb( Efl.Access.ReadingInfoCb description_cb,  System.IntPtr data) {
2256                                                          Efl.Access.IObjectNativeInherit.efl_access_object_description_cb_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), description_cb,  data);
2257         Eina.Error.RaiseIfUnhandledException();
2258                                          }
2259     /// <summary>Sets gesture callback to give widget.
2260     /// Warning: Please do not abuse this API. The purpose of this API is to support special application such as screen-reader guidance. Before using this API, please check if there is another way.
2261     ///
2262     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2263     /// <param name="gesture_cb"></param>
2264     /// <param name="data"></param>
2265     /// <returns></returns>
2266     virtual public void SetGestureCb( Efl.Access.GestureCb gesture_cb,  System.IntPtr data) {
2267                                                          Efl.Access.IObjectNativeInherit.efl_access_object_gesture_cb_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), gesture_cb,  data);
2268         Eina.Error.RaiseIfUnhandledException();
2269                                          }
2270     /// <summary>Gets object&apos;s accessible children.</summary>
2271     /// <returns>List of widget&apos;s children</returns>
2272     virtual public Eina.List<Efl.Access.IObject> GetAccessChildren() {
2273          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_access_children_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2274         Eina.Error.RaiseIfUnhandledException();
2275         return new Eina.List<Efl.Access.IObject>(_ret_var, true, false);
2276  }
2277     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
2278     /// <returns>Accessible role name</returns>
2279     virtual public System.String GetRoleName() {
2280          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_role_name_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2281         Eina.Error.RaiseIfUnhandledException();
2282         return _ret_var;
2283  }
2284     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
2285     /// <returns>List of object attributes, Must be freed by the user</returns>
2286     virtual public Eina.List<Efl.Access.Attribute> GetAttributes() {
2287          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_attributes_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2288         Eina.Error.RaiseIfUnhandledException();
2289         return new Eina.List<Efl.Access.Attribute>(_ret_var, true, true);
2290  }
2291     /// <summary>Gets reading information types of an accessible object. if no reading information is set, 0 is returned which means all four reading information types will be read on object highlight
2292     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2293     /// <returns>Reading information types</returns>
2294     virtual public Efl.Access.ReadingInfoTypeMask GetReadingInfoType() {
2295          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_reading_info_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2296         Eina.Error.RaiseIfUnhandledException();
2297         return _ret_var;
2298  }
2299     /// <summary>Sets reading information of an accessible object. If set as 0, existing reading info will be deleted and by default all four reading information types like name, role, state and description will be read on object highlight
2300     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2301     /// <param name="reading_info">Reading information types</param>
2302     /// <returns></returns>
2303     virtual public void SetReadingInfoType( Efl.Access.ReadingInfoTypeMask reading_info) {
2304                                  Efl.Access.IObjectNativeInherit.efl_access_object_reading_info_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), reading_info);
2305         Eina.Error.RaiseIfUnhandledException();
2306                          }
2307     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
2308     /// <returns>Index in children list</returns>
2309     virtual public int GetIndexInParent() {
2310          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_index_in_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2311         Eina.Error.RaiseIfUnhandledException();
2312         return _ret_var;
2313  }
2314     /// <summary>Gets contextual information about object.</summary>
2315     /// <returns>Accessible contextual information</returns>
2316     virtual public System.String GetDescription() {
2317          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_description_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2318         Eina.Error.RaiseIfUnhandledException();
2319         return _ret_var;
2320  }
2321     /// <summary>Sets widget contextual information.</summary>
2322     /// <param name="description">Accessible contextual information</param>
2323     /// <returns></returns>
2324     virtual public void SetDescription( System.String description) {
2325                                  Efl.Access.IObjectNativeInherit.efl_access_object_description_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), description);
2326         Eina.Error.RaiseIfUnhandledException();
2327                          }
2328     /// <summary>Gets set describing object accessible states.</summary>
2329     /// <returns>Accessible state set</returns>
2330     virtual public Efl.Access.StateSet GetStateSet() {
2331          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_state_set_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2332         Eina.Error.RaiseIfUnhandledException();
2333         return _ret_var;
2334  }
2335     /// <summary>Gets highlightable of given widget.
2336     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2337     /// <returns>If @c true, the object is highlightable.</returns>
2338     virtual public bool GetCanHighlight() {
2339          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_can_highlight_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2340         Eina.Error.RaiseIfUnhandledException();
2341         return _ret_var;
2342  }
2343     /// <summary>Sets highlightable to given widget.
2344     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2345     /// <param name="can_highlight">If @c true, the object is highlightable.</param>
2346     /// <returns></returns>
2347     virtual public void SetCanHighlight( bool can_highlight) {
2348                                  Efl.Access.IObjectNativeInherit.efl_access_object_can_highlight_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), can_highlight);
2349         Eina.Error.RaiseIfUnhandledException();
2350                          }
2351     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
2352     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
2353     ///
2354     /// When translation domain is set, values of &quot;name&quot; and &quot;description&quot; properties will be translated with the dgettext function using the current translation domain as the &quot;domainname&quot; parameter.
2355     ///
2356     /// It is the application developer&apos;s responsibility to ensure that translation files are loaded and bound to the translation domain when accessibility is enabled.</summary>
2357     /// <returns>Translation domain</returns>
2358     virtual public System.String GetTranslationDomain() {
2359          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_translation_domain_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2360         Eina.Error.RaiseIfUnhandledException();
2361         return _ret_var;
2362  }
2363     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
2364     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
2365     ///
2366     /// When translation domain is set, values of &quot;name&quot; and &quot;description&quot; properties will be translated with the dgettext function using the current translation domain as the &quot;domainname&quot; parameter.
2367     ///
2368     /// It is the application developer&apos;s responsibility to ensure that translation files are loaded and bound to the translation domain when accessibility is enabled.</summary>
2369     /// <param name="domain">Translation domain</param>
2370     /// <returns></returns>
2371     virtual public void SetTranslationDomain( System.String domain) {
2372                                  Efl.Access.IObjectNativeInherit.efl_access_object_translation_domain_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), domain);
2373         Eina.Error.RaiseIfUnhandledException();
2374                          }
2375     /// <summary>Get root object of accessible object hierarchy</summary>
2376     /// <returns>Root object</returns>
2377     public static Efl.Object GetAccessRoot() {
2378          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_access_root_get_ptr.Value.Delegate();
2379         Eina.Error.RaiseIfUnhandledException();
2380         return _ret_var;
2381  }
2382     /// <summary>Handles gesture on given widget.</summary>
2383     /// <param name="gesture_info"></param>
2384     /// <returns></returns>
2385     virtual public bool GestureDo( Efl.Access.GestureInfo gesture_info) {
2386          Efl.Access.GestureInfo.NativeStruct _in_gesture_info = gesture_info;
2387                         var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_gesture_do_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_gesture_info);
2388         Eina.Error.RaiseIfUnhandledException();
2389                         return _ret_var;
2390  }
2391     /// <summary>Add key-value pair identifying object extra attribute
2392     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2393     /// <param name="key">The string key to give extra information</param>
2394     /// <param name="value">The string value to give extra information</param>
2395     /// <returns></returns>
2396     virtual public void AppendAttribute( System.String key,  System.String value) {
2397                                                          Efl.Access.IObjectNativeInherit.efl_access_object_attribute_append_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key,  value);
2398         Eina.Error.RaiseIfUnhandledException();
2399                                          }
2400     /// <summary>delete key-value pair identifying object extra attributes when key is given</summary>
2401     /// <param name="key">The string key to identify the key-value pair</param>
2402     /// <returns></returns>
2403     virtual public void DelAttribute( System.String key) {
2404                                  Efl.Access.IObjectNativeInherit.efl_access_object_attribute_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key);
2405         Eina.Error.RaiseIfUnhandledException();
2406                          }
2407     /// <summary>Removes all attributes in accessible object.</summary>
2408     /// <returns></returns>
2409     virtual public void ClearAttributes() {
2410          Efl.Access.IObjectNativeInherit.efl_access_object_attributes_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2411         Eina.Error.RaiseIfUnhandledException();
2412          }
2413     /// <summary>Register accessibility event listener</summary>
2414     /// <param name="cb">Callback</param>
2415     /// <param name="data">Data</param>
2416     /// <returns>Event handler</returns>
2417     public static Efl.Access.Event.Handler AddEventHandler( Efl.EventCb cb,  System.IntPtr data) {
2418                                                          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_event_handler_add_ptr.Value.Delegate( cb,  data);
2419         Eina.Error.RaiseIfUnhandledException();
2420                                         return _ret_var;
2421  }
2422     /// <summary>Deregister accessibility event listener</summary>
2423     /// <param name="handler">Event handler</param>
2424     /// <returns></returns>
2425     public static void DelEventHandler( Efl.Access.Event.Handler handler) {
2426                                  Efl.Access.IObjectNativeInherit.efl_access_object_event_handler_del_ptr.Value.Delegate( handler);
2427         Eina.Error.RaiseIfUnhandledException();
2428                          }
2429     /// <summary>Emit event</summary>
2430     /// <param name="accessible">Accessibility object.</param>
2431     /// <param name="kw_event">Accessibility event type.</param>
2432     /// <param name="event_info">Accessibility event details.</param>
2433     /// <returns></returns>
2434     public static void EmitEvent( Efl.Access.IObject accessible,  Efl.EventDescription kw_event,  System.IntPtr event_info) {
2435                  var _in_kw_event = Eina.PrimitiveConversion.ManagedToPointerAlloc(kw_event);
2436                                                                 Efl.Access.IObjectNativeInherit.efl_access_object_event_emit_ptr.Value.Delegate( accessible,  _in_kw_event,  event_info);
2437         Eina.Error.RaiseIfUnhandledException();
2438                                                          }
2439     /// <summary>Defines the relationship between two accessible objects.
2440     /// Adds a unique relationship between source object and relation_object of a given type.
2441     ///
2442     /// Relationships can be queried by Assistive Technology clients to provide customized feedback, improving overall user experience.
2443     ///
2444     /// Relationship_append API is asymmetric, which means that appending, for example, relation EFL_ACCESS_RELATION_TYPE_FLOWS_TO from object A to B, do NOT append relation EFL_ACCESS_RELATION_TYPE_FLOWS_FROM from object B to object A.</summary>
2445     /// <param name="type">Relation type</param>
2446     /// <param name="relation_object">Object to relate to</param>
2447     /// <returns><c>true</c> if relationship was successfully appended, <c>false</c> otherwise</returns>
2448     virtual public bool AppendRelationship( Efl.Access.RelationType type,  Efl.Access.IObject relation_object) {
2449                                                          var _ret_var = Efl.Access.IObjectNativeInherit.efl_access_object_relationship_append_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  relation_object);
2450         Eina.Error.RaiseIfUnhandledException();
2451                                         return _ret_var;
2452  }
2453     /// <summary>Removes the relationship between two accessible objects.
2454     /// If relation_object is NULL function removes all relations of the given type.</summary>
2455     /// <param name="type">Relation type</param>
2456     /// <param name="relation_object">Object to remove relation from</param>
2457     /// <returns></returns>
2458     virtual public void RelationshipRemove( Efl.Access.RelationType type,  Efl.Access.IObject relation_object) {
2459                                                          Efl.Access.IObjectNativeInherit.efl_access_object_relationship_remove_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  relation_object);
2460         Eina.Error.RaiseIfUnhandledException();
2461                                          }
2462     /// <summary>Removes all relationships in accessible object.</summary>
2463     /// <returns></returns>
2464     virtual public void ClearRelationships() {
2465          Efl.Access.IObjectNativeInherit.efl_access_object_relationships_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2466         Eina.Error.RaiseIfUnhandledException();
2467          }
2468     /// <summary>Notifies accessibility clients about current state of the accessible object.
2469     /// Function limits information broadcast to clients to types specified by state_types_mask parameter.
2470     ///
2471     /// if recursive parameter is set, function will traverse all accessible children and call state_notify function on them.</summary>
2472     /// <param name="state_types_mask"></param>
2473     /// <param name="recursive"></param>
2474     /// <returns></returns>
2475     virtual public void StateNotify( Efl.Access.StateSet state_types_mask,  bool recursive) {
2476                                                          Efl.Access.IObjectNativeInherit.efl_access_object_state_notify_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), state_types_mask,  recursive);
2477         Eina.Error.RaiseIfUnhandledException();
2478                                          }
2479     /// <summary>Elementary actions</summary>
2480     /// <returns>NULL-terminated array of Efl.Access.Action_Data.</returns>
2481     virtual public Efl.Access.ActionData GetElmActions() {
2482          var _ret_var = Efl.Access.Widget.IActionNativeInherit.efl_access_widget_action_elm_actions_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2483         Eina.Error.RaiseIfUnhandledException();
2484         return _ret_var;
2485  }
2486     /// <summary>Start a drag and drop process at the drag side. During dragging, there are three events emitted as belows: - EFL_UI_DND_EVENT_DRAG_POS - EFL_UI_DND_EVENT_DRAG_ACCEPT - EFL_UI_DND_EVENT_DRAG_DONE</summary>
2487     /// <param name="format">The data format</param>
2488     /// <param name="data">The drag data</param>
2489     /// <param name="action">Action when data is transferred</param>
2490     /// <param name="icon_func">Function pointer to create icon</param>
2491     /// <param name="seat">Specified seat for multiple seats case.</param>
2492     /// <returns></returns>
2493     virtual public void DragStart( Efl.Ui.SelectionFormat format,  Eina.Slice data,  Efl.Ui.SelectionAction action,  Efl.Dnd.DragIconCreate icon_func,  uint seat) {
2494                                                                                                                  GCHandle icon_func_handle = GCHandle.Alloc(icon_func);
2495                 Efl.Ui.IDndNativeInherit.efl_ui_dnd_drag_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), format,  data,  action, GCHandle.ToIntPtr(icon_func_handle), Efl.Dnd.DragIconCreateWrapper.Cb, Efl.Eo.Globals.free_gchandle,  seat);
2496         Eina.Error.RaiseIfUnhandledException();
2497                                                                                          }
2498     /// <summary>Set the action for the drag</summary>
2499     /// <param name="action">Drag action</param>
2500     /// <param name="seat">Specified seat for multiple seats case.</param>
2501     /// <returns></returns>
2502     virtual public void SetDragAction( Efl.Ui.SelectionAction action,  uint seat) {
2503                                                          Efl.Ui.IDndNativeInherit.efl_ui_dnd_drag_action_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), action,  seat);
2504         Eina.Error.RaiseIfUnhandledException();
2505                                          }
2506     /// <summary>Cancel the on-going drag</summary>
2507     /// <param name="seat">Specified seat for multiple seats case.</param>
2508     /// <returns></returns>
2509     virtual public void DragCancel( uint seat) {
2510                                  Efl.Ui.IDndNativeInherit.efl_ui_dnd_drag_cancel_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), seat);
2511         Eina.Error.RaiseIfUnhandledException();
2512                          }
2513     /// <summary>Make the current object as drop target. There are four events emitted: - EFL_UI_DND_EVENT_DRAG_ENTER - EFL_UI_DND_EVENT_DRAG_LEAVE - EFL_UI_DND_EVENT_DRAG_POS - EFL_UI_DND_EVENT_DRAG_DROP.</summary>
2514     /// <param name="format">Accepted data format</param>
2515     /// <param name="seat">Specified seat for multiple seats case.</param>
2516     /// <returns></returns>
2517     virtual public void AddDropTarget( Efl.Ui.SelectionFormat format,  uint seat) {
2518                                                          Efl.Ui.IDndNativeInherit.efl_ui_dnd_drop_target_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), format,  seat);
2519         Eina.Error.RaiseIfUnhandledException();
2520                                          }
2521     /// <summary>Delete the dropable status from object</summary>
2522     /// <param name="format">Accepted data format</param>
2523     /// <param name="seat">Specified seat for multiple seats case.</param>
2524     /// <returns></returns>
2525     virtual public void DelDropTarget( Efl.Ui.SelectionFormat format,  uint seat) {
2526                                                          Efl.Ui.IDndNativeInherit.efl_ui_dnd_drop_target_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), format,  seat);
2527         Eina.Error.RaiseIfUnhandledException();
2528                                          }
2529     /// <summary>A unique string to be translated.
2530     /// Often this will be a human-readable string (e.g. in English) but it can also be a unique string identifier that must then be translated to the current locale with <c>dgettext</c>() or any similar mechanism.
2531     ///
2532     /// Setting this property will enable translation for this object or part.</summary>
2533     /// <param name="domain">A translation domain. If <c>null</c> this means the default domain is used.</param>
2534     /// <returns>This returns the untranslated value of <c>label</c>. The translated string can usually be retrieved with <see cref="Efl.IText.GetText"/>.</returns>
2535     virtual public System.String GetL10nText( out System.String domain) {
2536                                  var _ret_var = Efl.Ui.IL10nNativeInherit.efl_ui_l10n_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out domain);
2537         Eina.Error.RaiseIfUnhandledException();
2538                         return _ret_var;
2539  }
2540     /// <summary>Sets the new untranslated string and domain for this object.</summary>
2541     /// <param name="label">A unique (untranslated) string.</param>
2542     /// <param name="domain">A translation domain. If <c>null</c> this uses the default domain (eg. set by <c>textdomain</c>()).</param>
2543     /// <returns></returns>
2544     virtual public void SetL10nText( System.String label,  System.String domain) {
2545                                                          Efl.Ui.IL10nNativeInherit.efl_ui_l10n_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), label,  domain);
2546         Eina.Error.RaiseIfUnhandledException();
2547                                          }
2548     /// <summary>Requests this object to update its text strings for the current locale.
2549     /// Currently strings are translated with <c>dgettext</c>, so support for this function may depend on the platform. It is up to the application to provide its own translation data.
2550     ///
2551     /// This function is a hook meant to be implemented by any object that supports translation. This can be called whenever a new object is created or when the current locale changes, for instance. This should only trigger further calls to <see cref="Efl.Ui.IL10n.UpdateTranslation"/> to children objects.</summary>
2552     /// <returns></returns>
2553     virtual public void UpdateTranslation() {
2554          Efl.Ui.IL10nNativeInherit.efl_ui_l10n_translation_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2555         Eina.Error.RaiseIfUnhandledException();
2556          }
2557     /// <summary>bind property data with the given key string. when the data is ready or changed, bind the data to the key action and process promised work.</summary>
2558     /// <param name="key">key string for bind model property data</param>
2559     /// <param name="property">Model property name</param>
2560     /// <returns>0 when it succeed, an error code otherwise.</returns>
2561     virtual public Eina.Error PropertyBind( System.String key,  System.String property) {
2562                                                          var _ret_var = Efl.Ui.IPropertyBindNativeInherit.efl_ui_property_bind_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key,  property);
2563         Eina.Error.RaiseIfUnhandledException();
2564                                         return _ret_var;
2565  }
2566     /// <summary>Set the selection data to the object</summary>
2567     /// <param name="type">Selection Type</param>
2568     /// <param name="format">Selection Format</param>
2569     /// <param name="data">Selection data</param>
2570     /// <param name="seat">Specified seat for multiple seats case.</param>
2571     /// <returns>Future for tracking when the selection is lost</returns>
2572     virtual public  Eina.Future SetSelection( Efl.Ui.SelectionType type,  Efl.Ui.SelectionFormat format,  Eina.Slice data,  uint seat) {
2573                                                                                                          var _ret_var = Efl.Ui.ISelectionNativeInherit.efl_ui_selection_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  format,  data,  seat);
2574         Eina.Error.RaiseIfUnhandledException();
2575                                                                         return _ret_var;
2576  }
2577     /// <summary>Get the data from the object that has selection</summary>
2578     /// <param name="type">Selection Type</param>
2579     /// <param name="format">Selection Format</param>
2580     /// <param name="data_func">Data ready function pointer</param>
2581     /// <param name="seat">Specified seat for multiple seats case.</param>
2582     /// <returns></returns>
2583     virtual public void GetSelection( Efl.Ui.SelectionType type,  Efl.Ui.SelectionFormat format,  Efl.Ui.SelectionDataReady data_func,  uint seat) {
2584                                                                                          GCHandle data_func_handle = GCHandle.Alloc(data_func);
2585                 Efl.Ui.ISelectionNativeInherit.efl_ui_selection_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  format, GCHandle.ToIntPtr(data_func_handle), Efl.Ui.SelectionDataReadyWrapper.Cb, Efl.Eo.Globals.free_gchandle,  seat);
2586         Eina.Error.RaiseIfUnhandledException();
2587                                                                          }
2588     /// <summary>Clear the selection data from the object</summary>
2589     /// <param name="type">Selection Type</param>
2590     /// <param name="seat">Specified seat for multiple seats case.</param>
2591     /// <returns></returns>
2592     virtual public void ClearSelection( Efl.Ui.SelectionType type,  uint seat) {
2593                                                          Efl.Ui.ISelectionNativeInherit.efl_ui_selection_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  seat);
2594         Eina.Error.RaiseIfUnhandledException();
2595                                          }
2596     /// <summary>Determine whether the selection data has owner</summary>
2597     /// <param name="type">Selection type</param>
2598     /// <param name="seat">Specified seat for multiple seats case.</param>
2599     /// <returns>EINA_TRUE if there is object owns selection, otherwise EINA_FALSE</returns>
2600     virtual public bool HasOwner( Efl.Ui.SelectionType type,  uint seat) {
2601                                                          var _ret_var = Efl.Ui.ISelectionNativeInherit.efl_ui_selection_has_owner_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), type,  seat);
2602         Eina.Error.RaiseIfUnhandledException();
2603                                         return _ret_var;
2604  }
2605     /// <summary>Model that is/will be</summary>
2606     /// <returns>Efl model</returns>
2607     virtual public Efl.IModel GetModel() {
2608          var _ret_var = Efl.Ui.IViewNativeInherit.efl_ui_view_model_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2609         Eina.Error.RaiseIfUnhandledException();
2610         return _ret_var;
2611  }
2612     /// <summary>Model that is/will be</summary>
2613     /// <param name="model">Efl model</param>
2614     /// <returns></returns>
2615     virtual public void SetModel( Efl.IModel model) {
2616                                  Efl.Ui.IViewNativeInherit.efl_ui_view_model_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), model);
2617         Eina.Error.RaiseIfUnhandledException();
2618                          }
2619     /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
2620     /// (Since EFL 1.22)</summary>
2621     /// <returns>The geometry to use.</returns>
2622     virtual public Eina.Rect GetFocusGeometry() {
2623          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_focus_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2624         Eina.Error.RaiseIfUnhandledException();
2625         return _ret_var;
2626  }
2627     /// <summary>Returns whether the widget is currently focused or not.
2628     /// (Since EFL 1.22)</summary>
2629     /// <returns>The focused state of the object.</returns>
2630     virtual public bool GetFocus() {
2631          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_focus_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2632         Eina.Error.RaiseIfUnhandledException();
2633         return _ret_var;
2634  }
2635     /// <summary>This is called by the manager and should never be called by anyone else.
2636     /// The function emits the focus state events, if focus is different to the previous state.
2637     /// (Since EFL 1.22)</summary>
2638     /// <param name="focus">The focused state of the object.</param>
2639     /// <returns></returns>
2640     virtual public void SetFocus( bool focus) {
2641                                  Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_focus_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), focus);
2642         Eina.Error.RaiseIfUnhandledException();
2643                          }
2644     /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
2645     /// (Since EFL 1.22)</summary>
2646     /// <returns>The manager object</returns>
2647     virtual public Efl.Ui.Focus.IManager GetFocusManager() {
2648          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_focus_manager_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2649         Eina.Error.RaiseIfUnhandledException();
2650         return _ret_var;
2651  }
2652     /// <summary>Describes which logical parent is used by this object.
2653     /// (Since EFL 1.22)</summary>
2654     /// <returns>The focus parent.</returns>
2655     virtual public Efl.Ui.Focus.IObject GetFocusParent() {
2656          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_focus_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2657         Eina.Error.RaiseIfUnhandledException();
2658         return _ret_var;
2659  }
2660     /// <summary>Indicates if a child of this object has focus set to true.
2661     /// (Since EFL 1.22)</summary>
2662     /// <returns><c>true</c> if a child has focus.</returns>
2663     virtual public bool GetChildFocus() {
2664          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_child_focus_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2665         Eina.Error.RaiseIfUnhandledException();
2666         return _ret_var;
2667  }
2668     /// <summary>Indicates if a child of this object has focus set to true.
2669     /// (Since EFL 1.22)</summary>
2670     /// <param name="child_focus"><c>true</c> if a child has focus.</param>
2671     /// <returns></returns>
2672     virtual public void SetChildFocus( bool child_focus) {
2673                                  Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_child_focus_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), child_focus);
2674         Eina.Error.RaiseIfUnhandledException();
2675                          }
2676     /// <summary>Tells the object that its children will be queried soon by the focus manager. Overwrite this to update the order of the children. Deleting items in this call will result in undefined behaviour and may cause your system to crash.
2677     /// (Since EFL 1.22)</summary>
2678     /// <returns></returns>
2679     virtual public void SetupOrder() {
2680          Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_setup_order_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2681         Eina.Error.RaiseIfUnhandledException();
2682          }
2683     /// <summary>This is called when <see cref="Efl.Ui.Focus.IObject.SetupOrder"/> is called, but only on the first call, additional recursive calls to <see cref="Efl.Ui.Focus.IObject.SetupOrder"/> will not call this function again.
2684     /// (Since EFL 1.22)</summary>
2685     /// <returns></returns>
2686     virtual public void SetupOrderNonRecursive() {
2687          Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_setup_order_non_recursive_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2688         Eina.Error.RaiseIfUnhandledException();
2689          }
2690     /// <summary>Virtual function handling focus in/out events on the widget
2691     /// (Since EFL 1.22)</summary>
2692     /// <returns><c>true</c> if this widget can handle focus, <c>false</c> otherwise</returns>
2693     virtual public bool UpdateOnFocus() {
2694          var _ret_var = Efl.Ui.Focus.IObjectNativeInherit.efl_ui_focus_object_on_focus_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2695         Eina.Error.RaiseIfUnhandledException();
2696         return _ret_var;
2697  }
2698     public System.Threading.Tasks.Task<Eina.Value> SetSelectionAsync( Efl.Ui.SelectionType type, Efl.Ui.SelectionFormat format, Eina.Slice data, uint seat, System.Threading.CancellationToken token=default(System.Threading.CancellationToken))
2699     {
2700         Eina.Future future = SetSelection(  type,  format,  data,  seat);
2701         return Efl.Eo.Globals.WrapAsync(future, token);
2702     }
2703     /// <summary>The cursor to be shown when mouse is over the object
2704 /// This is the cursor that will be displayed when mouse is over the object. The object can have only one cursor set to it so if <see cref="Efl.Ui.Widget.SetCursor"/> is called twice for an object, the previous set will be unset.
2705 ///
2706 /// If using X cursors, a definition of all the valid cursor names is listed on Elementary_Cursors.h. If an invalid name is set the default cursor will be used.
2707 /// (Since EFL 1.22)</summary>
2708 /// <value>The cursor name, defined either by the display system or the theme.</value>
2709     public System.String Cursor {
2710         get { return GetCursor(); }
2711         set { SetCursor( value); }
2712     }
2713     /// <summary>A different style for the cursor.
2714 /// This only makes sense if theme cursors are used. The cursor should be set with <see cref="Efl.Ui.Widget.SetCursor"/> first before setting its style with this property.
2715 /// (Since EFL 1.22)</summary>
2716 /// <value>A specific style to use, eg. default, transparent, ....</value>
2717     public System.String CursorStyle {
2718         get { return GetCursorStyle(); }
2719         set { SetCursorStyle( value); }
2720     }
2721     /// <summary>Whether the cursor may be looked in the theme or not.
2722 /// If <c>false</c>, the cursor may only come from the render engine, i.e. from the display manager.
2723 /// (Since EFL 1.22)</summary>
2724 /// <value>Whether to use theme cursors.</value>
2725     public bool CursorThemeSearchEnabled {
2726         get { return GetCursorThemeSearchEnabled(); }
2727         set { SetCursorThemeSearchEnabled( value); }
2728     }
2729     /// <summary>This is the internal canvas object managed by a widget.
2730 /// This property is protected as it is meant for widget implementations only, to set and access the internal canvas object. Do use this function unless you&apos;re implementing a widget.
2731 /// (Since EFL 1.22)</summary>
2732 /// <value>A canvas object (often a <see cref="Efl.Canvas.Layout"/> object).</value>
2733     public Efl.Canvas.Object ResizeObject {
2734         set { SetResizeObject( value); }
2735     }
2736     /// <summary>Whether the widget is enabled (accepts and reacts to user inputs).
2737 /// The property works counted, this means, whenever n-caller set the value to <c>true</c>, n-caller have to set it to <c>false</c> in order to get it out of the disabled state again.
2738 ///
2739 /// Each widget may handle the disabled state differently, but overall disabled widgets shall not respond to any input events. This is <c>false</c> by default, meaning the widget is enabled.
2740 /// (Since EFL 1.22)</summary>
2741 /// <value><c>true</c> if the widget is disabled.</value>
2742     public bool Disabled {
2743         get { return GetDisabled(); }
2744         set { SetDisabled( value); }
2745     }
2746     /// <summary>The widget style to use.
2747 /// Styles define different look and feel for widgets, and may provide different parts for layout-based widgets. Styles vary from widget to widget and may be defined by other themes by means of extensions and overlays.
2748 ///
2749 /// The style can only be set before <see cref="Efl.Object.FinalizeAdd"/>, which means at construction time of the object (inside <c>efl_add</c> in C).
2750 /// (Since EFL 1.22)</summary>
2751 /// <value>Name of the style to use. Refer to each widget&apos;s documentation for the available style names, or to the themes in use.</value>
2752     public System.String Style {
2753         get { return GetStyle(); }
2754         set { SetStyle( value); }
2755     }
2756     /// <summary>The ability for a widget to be focused.
2757 /// Unfocusable objects do nothing when programmatically focused. The nearest focusable parent object the one really getting focus. Also, when they receive mouse input, they will get the event, but not take away the focus from where it was previously.
2758 ///
2759 /// Note: Objects which are meant to be interacted with by input events are created able to be focused, by default. All the others are not.
2760 ///
2761 /// This property&apos;s default value depends on the widget (eg. a box is not focusable, but a button is).
2762 /// (Since EFL 1.22)</summary>
2763 /// <value>Whether the object is focusable.</value>
2764     public bool FocusAllow {
2765         get { return GetFocusAllow(); }
2766         set { SetFocusAllow( value); }
2767     }
2768     /// <summary>The internal parent of this widget.
2769 /// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
2770 /// (Since EFL 1.22)</summary>
2771 /// <value>Widget parent object</value>
2772     public Efl.Ui.Widget WidgetParent {
2773         get { return GetWidgetParent(); }
2774         set { SetWidgetParent( value); }
2775     }
2776     /// <summary>Accessibility information.
2777 /// This is a replacement string to be read by the accessibility text-to-speech engine, if accessibility is enabled by configuration. This will take precedence over the default text for this object, which means for instance that the label of a button won&apos;t be read out loud, instead <c>txt</c> will be read out.
2778 /// (Since EFL 1.22)</summary>
2779 /// <value>Accessibility text description.</value>
2780     public System.String AccessInfo {
2781         get { return GetAccessInfo(); }
2782         set { SetAccessInfo( value); }
2783     }
2784     /// <summary>Region of interest inside this widget, that should be given priority to be visible inside a scroller.
2785 /// When this widget or one of its subwidgets is given focus, this region should be shown, which means any parent scroller should attempt to display the given area of this widget. For instance, an entry given focus should scroll to show the text cursor if that cursor moves. In this example, this region defines the relative geometry of the cursor within the widget.
2786 ///
2787 /// Note: The region is relative to the top-left corner of the widget, i.e. X,Y start from 0,0 to indicate the top-left corner of the widget. W,H must be greater or equal to 1 for this region to be taken into account, otherwise it is ignored.
2788 /// (Since EFL 1.22)</summary>
2789 /// <value>The relative region to show. If width or height is &lt;= 0 it will be ignored, and no action will be taken.</value>
2790     public Eina.Rect InterestRegion {
2791         get { return GetInterestRegion(); }
2792     }
2793     /// <summary>The rectangle region to be highlighted on focus.
2794 /// This is a rectangle region where the focus highlight should be displayed.
2795 /// (Since EFL 1.22)</summary>
2796 /// <value>The rectangle area.</value>
2797     public Eina.Rect FocusHighlightGeometry {
2798         get { return GetFocusHighlightGeometry(); }
2799     }
2800     /// <summary>Focus order property
2801 /// (Since EFL 1.22)</summary>
2802 /// <value>FIXME</value>
2803     public uint FocusOrder {
2804         get { return GetFocusOrder(); }
2805     }
2806     /// <summary>A custom chain of objects to pass focus.
2807 /// Note: On focus cycle, only will be evaluated children of this container.
2808 /// (Since EFL 1.22)</summary>
2809 /// <value>Chain of objects to pass focus</value>
2810     public Eina.List<Efl.Canvas.Object> FocusCustomChain {
2811         get { return GetFocusCustomChain(); }
2812         set { SetFocusCustomChain( value); }
2813     }
2814     /// <summary>Current focused object in object tree.
2815 /// (Since EFL 1.22)</summary>
2816 /// <value>Current focused or <c>null</c>, if there is no focused object.</value>
2817     public Efl.Canvas.Object FocusedObject {
2818         get { return GetFocusedObject(); }
2819     }
2820     /// <summary>The widget&apos;s focus move policy.
2821 /// (Since EFL 1.22)</summary>
2822 /// <value>Focus move policy</value>
2823     public Efl.Ui.Focus.MovePolicy FocusMovePolicy {
2824         get { return GetFocusMovePolicy(); }
2825         set { SetFocusMovePolicy( value); }
2826     }
2827     /// <summary>Control the widget&apos;s focus_move_policy mode setting.
2828 /// (Since EFL 1.22)</summary>
2829 /// <value><c>true</c> to follow system focus move policy change, <c>false</c> otherwise</value>
2830     public bool FocusMovePolicyAutomatic {
2831         get { return GetFocusMovePolicyAutomatic(); }
2832         set { SetFocusMovePolicyAutomatic( value); }
2833     }
2834     /// <summary>Get list of available widget actions</summary>
2835 /// <value>Contains statically allocated strings.</value>
2836     public Eina.List<Efl.Access.ActionData> Actions {
2837         get { return GetActions(); }
2838     }
2839     /// <summary>Gets the depth at which the component is shown in relation to other components in the same container.</summary>
2840 /// <value>Z order of component</value>
2841     public int ZOrder {
2842         get { return GetZOrder(); }
2843     }
2844     /// <summary>Gets an localized string describing accessible object role name.</summary>
2845 /// <value>Localized accessible object role name</value>
2846     public System.String LocalizedRoleName {
2847         get { return GetLocalizedRoleName(); }
2848     }
2849     /// <summary>Accessible name of the object.</summary>
2850 /// <value>Accessible name</value>
2851     public System.String I18nName {
2852         get { return GetI18nName(); }
2853         set { SetI18nName( value); }
2854     }
2855     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
2856 /// <value>Accessible relation set</value>
2857     public Efl.Access.RelationSet RelationSet {
2858         get { return GetRelationSet(); }
2859     }
2860     /// <summary>The role of the object in accessibility domain.</summary>
2861 /// <value>Accessible role</value>
2862     public Efl.Access.Role Role {
2863         get { return GetRole(); }
2864         set { SetRole( value); }
2865     }
2866     /// <summary>Gets object&apos;s accessible parent.</summary>
2867 /// <value>Accessible parent</value>
2868     public Efl.Access.IObject AccessParent {
2869         get { return GetAccessParent(); }
2870         set { SetAccessParent( value); }
2871     }
2872     /// <summary>Gets object&apos;s accessible children.</summary>
2873 /// <value>List of widget&apos;s children</value>
2874     public Eina.List<Efl.Access.IObject> AccessChildren {
2875         get { return GetAccessChildren(); }
2876     }
2877     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
2878 /// <value>Accessible role name</value>
2879     public System.String RoleName {
2880         get { return GetRoleName(); }
2881     }
2882     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
2883 /// <value>List of object attributes, Must be freed by the user</value>
2884     public Eina.List<Efl.Access.Attribute> Attributes {
2885         get { return GetAttributes(); }
2886     }
2887     /// <summary>Gets reading information types of an accessible object. if no reading information is set, 0 is returned which means all four reading information types will be read on object highlight
2888 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2889 /// <value>Reading information types</value>
2890     public Efl.Access.ReadingInfoTypeMask ReadingInfoType {
2891         get { return GetReadingInfoType(); }
2892         set { SetReadingInfoType( value); }
2893     }
2894     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
2895 /// <value>Index in children list</value>
2896     public int IndexInParent {
2897         get { return GetIndexInParent(); }
2898     }
2899     /// <summary>Gets contextual information about object.</summary>
2900 /// <value>Accessible contextual information</value>
2901     public System.String Description {
2902         get { return GetDescription(); }
2903         set { SetDescription( value); }
2904     }
2905     /// <summary>Gets set describing object accessible states.</summary>
2906 /// <value>Accessible state set</value>
2907     public Efl.Access.StateSet StateSet {
2908         get { return GetStateSet(); }
2909     }
2910     /// <summary>Gets highlightable of given widget.
2911 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
2912 /// <value>If @c true, the object is highlightable.</value>
2913     public bool CanHighlight {
2914         get { return GetCanHighlight(); }
2915         set { SetCanHighlight( value); }
2916     }
2917     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
2918 /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
2919 ///
2920 /// When translation domain is set, values of &quot;name&quot; and &quot;description&quot; properties will be translated with the dgettext function using the current translation domain as the &quot;domainname&quot; parameter.
2921 ///
2922 /// It is the application developer&apos;s responsibility to ensure that translation files are loaded and bound to the translation domain when accessibility is enabled.</summary>
2923 /// <value>Translation domain</value>
2924     public System.String TranslationDomain {
2925         get { return GetTranslationDomain(); }
2926         set { SetTranslationDomain( value); }
2927     }
2928     /// <summary>Get root object of accessible object hierarchy</summary>
2929 /// <value>Root object</value>
2930     public static Efl.Object AccessRoot {
2931         get { return GetAccessRoot(); }
2932     }
2933     /// <summary>Elementary actions</summary>
2934 /// <value>NULL-terminated array of Efl.Access.Action_Data.</value>
2935     public Efl.Access.ActionData ElmActions {
2936         get { return GetElmActions(); }
2937     }
2938     /// <summary>Model that is/will be</summary>
2939 /// <value>Efl model</value>
2940     public Efl.IModel Model {
2941         get { return GetModel(); }
2942         set { SetModel( value); }
2943     }
2944     /// <summary>The geometry (that is, the bounding rectangle) used to calculate the relationship with other objects.
2945 /// (Since EFL 1.22)</summary>
2946 /// <value>The geometry to use.</value>
2947     public Eina.Rect FocusGeometry {
2948         get { return GetFocusGeometry(); }
2949     }
2950     /// <summary>Returns whether the widget is currently focused or not.
2951 /// (Since EFL 1.22)</summary>
2952 /// <value>The focused state of the object.</value>
2953     public bool Focus {
2954         get { return GetFocus(); }
2955         set { SetFocus( value); }
2956     }
2957     /// <summary>This is the focus manager where this focus object is registered in. The element which is the <c>root</c> of a Efl.Ui.Focus.Manager will not have this focus manager as this object, but rather the second focus manager where it is registered in.
2958 /// (Since EFL 1.22)</summary>
2959 /// <value>The manager object</value>
2960     public Efl.Ui.Focus.IManager FocusManager {
2961         get { return GetFocusManager(); }
2962     }
2963     /// <summary>Describes which logical parent is used by this object.
2964 /// (Since EFL 1.22)</summary>
2965 /// <value>The focus parent.</value>
2966     public Efl.Ui.Focus.IObject FocusParent {
2967         get { return GetFocusParent(); }
2968     }
2969     /// <summary>Indicates if a child of this object has focus set to true.
2970 /// (Since EFL 1.22)</summary>
2971 /// <value><c>true</c> if a child has focus.</value>
2972     public bool ChildFocus {
2973         get { return GetChildFocus(); }
2974         set { SetChildFocus( value); }
2975     }
2976     private static IntPtr GetEflClassStatic()
2977     {
2978         return Efl.Ui.Widget.efl_ui_widget_class_get();
2979     }
2980 }
2981 public class WidgetNativeInherit : Efl.Canvas.GroupNativeInherit{
2982     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
2983     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
2984     {
2985         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
2986         var methods = Efl.Eo.Globals.GetUserMethods(type);
2987         if (efl_ui_widget_cursor_get_static_delegate == null)
2988             efl_ui_widget_cursor_get_static_delegate = new efl_ui_widget_cursor_get_delegate(cursor_get);
2989         if (methods.FirstOrDefault(m => m.Name == "GetCursor") != null)
2990             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_get_static_delegate)});
2991         if (efl_ui_widget_cursor_set_static_delegate == null)
2992             efl_ui_widget_cursor_set_static_delegate = new efl_ui_widget_cursor_set_delegate(cursor_set);
2993         if (methods.FirstOrDefault(m => m.Name == "SetCursor") != null)
2994             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_set_static_delegate)});
2995         if (efl_ui_widget_cursor_style_get_static_delegate == null)
2996             efl_ui_widget_cursor_style_get_static_delegate = new efl_ui_widget_cursor_style_get_delegate(cursor_style_get);
2997         if (methods.FirstOrDefault(m => m.Name == "GetCursorStyle") != null)
2998             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_style_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_style_get_static_delegate)});
2999         if (efl_ui_widget_cursor_style_set_static_delegate == null)
3000             efl_ui_widget_cursor_style_set_static_delegate = new efl_ui_widget_cursor_style_set_delegate(cursor_style_set);
3001         if (methods.FirstOrDefault(m => m.Name == "SetCursorStyle") != null)
3002             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_style_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_style_set_static_delegate)});
3003         if (efl_ui_widget_cursor_theme_search_enabled_get_static_delegate == null)
3004             efl_ui_widget_cursor_theme_search_enabled_get_static_delegate = new efl_ui_widget_cursor_theme_search_enabled_get_delegate(cursor_theme_search_enabled_get);
3005         if (methods.FirstOrDefault(m => m.Name == "GetCursorThemeSearchEnabled") != null)
3006             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_theme_search_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_theme_search_enabled_get_static_delegate)});
3007         if (efl_ui_widget_cursor_theme_search_enabled_set_static_delegate == null)
3008             efl_ui_widget_cursor_theme_search_enabled_set_static_delegate = new efl_ui_widget_cursor_theme_search_enabled_set_delegate(cursor_theme_search_enabled_set);
3009         if (methods.FirstOrDefault(m => m.Name == "SetCursorThemeSearchEnabled") != null)
3010             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_cursor_theme_search_enabled_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_cursor_theme_search_enabled_set_static_delegate)});
3011         if (efl_ui_widget_resize_object_set_static_delegate == null)
3012             efl_ui_widget_resize_object_set_static_delegate = new efl_ui_widget_resize_object_set_delegate(resize_object_set);
3013         if (methods.FirstOrDefault(m => m.Name == "SetResizeObject") != null)
3014             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_resize_object_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_resize_object_set_static_delegate)});
3015         if (efl_ui_widget_disabled_get_static_delegate == null)
3016             efl_ui_widget_disabled_get_static_delegate = new efl_ui_widget_disabled_get_delegate(disabled_get);
3017         if (methods.FirstOrDefault(m => m.Name == "GetDisabled") != null)
3018             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_disabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_disabled_get_static_delegate)});
3019         if (efl_ui_widget_disabled_set_static_delegate == null)
3020             efl_ui_widget_disabled_set_static_delegate = new efl_ui_widget_disabled_set_delegate(disabled_set);
3021         if (methods.FirstOrDefault(m => m.Name == "SetDisabled") != null)
3022             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_disabled_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_disabled_set_static_delegate)});
3023         if (efl_ui_widget_style_get_static_delegate == null)
3024             efl_ui_widget_style_get_static_delegate = new efl_ui_widget_style_get_delegate(style_get);
3025         if (methods.FirstOrDefault(m => m.Name == "GetStyle") != null)
3026             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_style_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_style_get_static_delegate)});
3027         if (efl_ui_widget_style_set_static_delegate == null)
3028             efl_ui_widget_style_set_static_delegate = new efl_ui_widget_style_set_delegate(style_set);
3029         if (methods.FirstOrDefault(m => m.Name == "SetStyle") != null)
3030             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_style_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_style_set_static_delegate)});
3031         if (efl_ui_widget_focus_allow_get_static_delegate == null)
3032             efl_ui_widget_focus_allow_get_static_delegate = new efl_ui_widget_focus_allow_get_delegate(focus_allow_get);
3033         if (methods.FirstOrDefault(m => m.Name == "GetFocusAllow") != null)
3034             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_allow_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_allow_get_static_delegate)});
3035         if (efl_ui_widget_focus_allow_set_static_delegate == null)
3036             efl_ui_widget_focus_allow_set_static_delegate = new efl_ui_widget_focus_allow_set_delegate(focus_allow_set);
3037         if (methods.FirstOrDefault(m => m.Name == "SetFocusAllow") != null)
3038             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_allow_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_allow_set_static_delegate)});
3039         if (efl_ui_widget_parent_get_static_delegate == null)
3040             efl_ui_widget_parent_get_static_delegate = new efl_ui_widget_parent_get_delegate(widget_parent_get);
3041         if (methods.FirstOrDefault(m => m.Name == "GetWidgetParent") != null)
3042             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_parent_get_static_delegate)});
3043         if (efl_ui_widget_parent_set_static_delegate == null)
3044             efl_ui_widget_parent_set_static_delegate = new efl_ui_widget_parent_set_delegate(widget_parent_set);
3045         if (methods.FirstOrDefault(m => m.Name == "SetWidgetParent") != null)
3046             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_parent_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_parent_set_static_delegate)});
3047         if (efl_ui_widget_access_info_get_static_delegate == null)
3048             efl_ui_widget_access_info_get_static_delegate = new efl_ui_widget_access_info_get_delegate(access_info_get);
3049         if (methods.FirstOrDefault(m => m.Name == "GetAccessInfo") != null)
3050             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_access_info_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_access_info_get_static_delegate)});
3051         if (efl_ui_widget_access_info_set_static_delegate == null)
3052             efl_ui_widget_access_info_set_static_delegate = new efl_ui_widget_access_info_set_delegate(access_info_set);
3053         if (methods.FirstOrDefault(m => m.Name == "SetAccessInfo") != null)
3054             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_access_info_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_access_info_set_static_delegate)});
3055         if (efl_ui_widget_interest_region_get_static_delegate == null)
3056             efl_ui_widget_interest_region_get_static_delegate = new efl_ui_widget_interest_region_get_delegate(interest_region_get);
3057         if (methods.FirstOrDefault(m => m.Name == "GetInterestRegion") != null)
3058             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_interest_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_interest_region_get_static_delegate)});
3059         if (efl_ui_widget_focus_highlight_geometry_get_static_delegate == null)
3060             efl_ui_widget_focus_highlight_geometry_get_static_delegate = new efl_ui_widget_focus_highlight_geometry_get_delegate(focus_highlight_geometry_get);
3061         if (methods.FirstOrDefault(m => m.Name == "GetFocusHighlightGeometry") != null)
3062             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_highlight_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_highlight_geometry_get_static_delegate)});
3063         if (efl_ui_widget_focus_order_get_static_delegate == null)
3064             efl_ui_widget_focus_order_get_static_delegate = new efl_ui_widget_focus_order_get_delegate(focus_order_get);
3065         if (methods.FirstOrDefault(m => m.Name == "GetFocusOrder") != null)
3066             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_order_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_order_get_static_delegate)});
3067         if (efl_ui_widget_focus_custom_chain_get_static_delegate == null)
3068             efl_ui_widget_focus_custom_chain_get_static_delegate = new efl_ui_widget_focus_custom_chain_get_delegate(focus_custom_chain_get);
3069         if (methods.FirstOrDefault(m => m.Name == "GetFocusCustomChain") != null)
3070             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_custom_chain_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_custom_chain_get_static_delegate)});
3071         if (efl_ui_widget_focus_custom_chain_set_static_delegate == null)
3072             efl_ui_widget_focus_custom_chain_set_static_delegate = new efl_ui_widget_focus_custom_chain_set_delegate(focus_custom_chain_set);
3073         if (methods.FirstOrDefault(m => m.Name == "SetFocusCustomChain") != null)
3074             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_custom_chain_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_custom_chain_set_static_delegate)});
3075         if (efl_ui_widget_focused_object_get_static_delegate == null)
3076             efl_ui_widget_focused_object_get_static_delegate = new efl_ui_widget_focused_object_get_delegate(focused_object_get);
3077         if (methods.FirstOrDefault(m => m.Name == "GetFocusedObject") != null)
3078             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focused_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focused_object_get_static_delegate)});
3079         if (efl_ui_widget_focus_move_policy_get_static_delegate == null)
3080             efl_ui_widget_focus_move_policy_get_static_delegate = new efl_ui_widget_focus_move_policy_get_delegate(focus_move_policy_get);
3081         if (methods.FirstOrDefault(m => m.Name == "GetFocusMovePolicy") != null)
3082             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_move_policy_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_move_policy_get_static_delegate)});
3083         if (efl_ui_widget_focus_move_policy_set_static_delegate == null)
3084             efl_ui_widget_focus_move_policy_set_static_delegate = new efl_ui_widget_focus_move_policy_set_delegate(focus_move_policy_set);
3085         if (methods.FirstOrDefault(m => m.Name == "SetFocusMovePolicy") != null)
3086             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_move_policy_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_move_policy_set_static_delegate)});
3087         if (efl_ui_widget_focus_move_policy_automatic_get_static_delegate == null)
3088             efl_ui_widget_focus_move_policy_automatic_get_static_delegate = new efl_ui_widget_focus_move_policy_automatic_get_delegate(focus_move_policy_automatic_get);
3089         if (methods.FirstOrDefault(m => m.Name == "GetFocusMovePolicyAutomatic") != null)
3090             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_move_policy_automatic_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_move_policy_automatic_get_static_delegate)});
3091         if (efl_ui_widget_focus_move_policy_automatic_set_static_delegate == null)
3092             efl_ui_widget_focus_move_policy_automatic_set_static_delegate = new efl_ui_widget_focus_move_policy_automatic_set_delegate(focus_move_policy_automatic_set);
3093         if (methods.FirstOrDefault(m => m.Name == "SetFocusMovePolicyAutomatic") != null)
3094             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_move_policy_automatic_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_move_policy_automatic_set_static_delegate)});
3095         if (efl_ui_widget_input_event_handler_static_delegate == null)
3096             efl_ui_widget_input_event_handler_static_delegate = new efl_ui_widget_input_event_handler_delegate(widget_input_event_handler);
3097         if (methods.FirstOrDefault(m => m.Name == "WidgetInputEventHandler") != null)
3098             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_input_event_handler"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_input_event_handler_static_delegate)});
3099         if (efl_ui_widget_on_access_activate_static_delegate == null)
3100             efl_ui_widget_on_access_activate_static_delegate = new efl_ui_widget_on_access_activate_delegate(on_access_activate);
3101         if (methods.FirstOrDefault(m => m.Name == "OnAccessActivate") != null)
3102             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_on_access_activate"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_on_access_activate_static_delegate)});
3103         if (efl_ui_widget_on_access_update_static_delegate == null)
3104             efl_ui_widget_on_access_update_static_delegate = new efl_ui_widget_on_access_update_delegate(on_access_update);
3105         if (methods.FirstOrDefault(m => m.Name == "UpdateOnAccess") != null)
3106             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_on_access_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_on_access_update_static_delegate)});
3107         if (efl_ui_widget_screen_reader_static_delegate == null)
3108             efl_ui_widget_screen_reader_static_delegate = new efl_ui_widget_screen_reader_delegate(screen_reader);
3109         if (methods.FirstOrDefault(m => m.Name == "ScreenReader") != null)
3110             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_screen_reader"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_screen_reader_static_delegate)});
3111         if (efl_ui_widget_atspi_static_delegate == null)
3112             efl_ui_widget_atspi_static_delegate = new efl_ui_widget_atspi_delegate(atspi);
3113         if (methods.FirstOrDefault(m => m.Name == "Atspi") != null)
3114             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_atspi"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_atspi_static_delegate)});
3115         if (efl_ui_widget_sub_object_add_static_delegate == null)
3116             efl_ui_widget_sub_object_add_static_delegate = new efl_ui_widget_sub_object_add_delegate(widget_sub_object_add);
3117         if (methods.FirstOrDefault(m => m.Name == "AddWidgetSubObject") != null)
3118             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_sub_object_add"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_sub_object_add_static_delegate)});
3119         if (efl_ui_widget_sub_object_del_static_delegate == null)
3120             efl_ui_widget_sub_object_del_static_delegate = new efl_ui_widget_sub_object_del_delegate(widget_sub_object_del);
3121         if (methods.FirstOrDefault(m => m.Name == "DelWidgetSubObject") != null)
3122             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_sub_object_del"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_sub_object_del_static_delegate)});
3123         if (efl_ui_widget_theme_apply_static_delegate == null)
3124             efl_ui_widget_theme_apply_static_delegate = new efl_ui_widget_theme_apply_delegate(theme_apply);
3125         if (methods.FirstOrDefault(m => m.Name == "ThemeApply") != null)
3126             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_theme_apply"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_theme_apply_static_delegate)});
3127         if (efl_ui_widget_scroll_hold_push_static_delegate == null)
3128             efl_ui_widget_scroll_hold_push_static_delegate = new efl_ui_widget_scroll_hold_push_delegate(scroll_hold_push);
3129         if (methods.FirstOrDefault(m => m.Name == "PushScrollHold") != null)
3130             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_scroll_hold_push"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_scroll_hold_push_static_delegate)});
3131         if (efl_ui_widget_scroll_hold_pop_static_delegate == null)
3132             efl_ui_widget_scroll_hold_pop_static_delegate = new efl_ui_widget_scroll_hold_pop_delegate(scroll_hold_pop);
3133         if (methods.FirstOrDefault(m => m.Name == "PopScrollHold") != null)
3134             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_scroll_hold_pop"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_scroll_hold_pop_static_delegate)});
3135         if (efl_ui_widget_scroll_freeze_push_static_delegate == null)
3136             efl_ui_widget_scroll_freeze_push_static_delegate = new efl_ui_widget_scroll_freeze_push_delegate(scroll_freeze_push);
3137         if (methods.FirstOrDefault(m => m.Name == "PushScrollFreeze") != null)
3138             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_scroll_freeze_push"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_scroll_freeze_push_static_delegate)});
3139         if (efl_ui_widget_scroll_freeze_pop_static_delegate == null)
3140             efl_ui_widget_scroll_freeze_pop_static_delegate = new efl_ui_widget_scroll_freeze_pop_delegate(scroll_freeze_pop);
3141         if (methods.FirstOrDefault(m => m.Name == "PopScrollFreeze") != null)
3142             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_scroll_freeze_pop"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_scroll_freeze_pop_static_delegate)});
3143         if (efl_ui_widget_part_access_object_get_static_delegate == null)
3144             efl_ui_widget_part_access_object_get_static_delegate = new efl_ui_widget_part_access_object_get_delegate(part_access_object_get);
3145         if (methods.FirstOrDefault(m => m.Name == "GetPartAccessObject") != null)
3146             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_part_access_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_part_access_object_get_static_delegate)});
3147         if (efl_ui_widget_newest_focus_order_get_static_delegate == null)
3148             efl_ui_widget_newest_focus_order_get_static_delegate = new efl_ui_widget_newest_focus_order_get_delegate(newest_focus_order_get);
3149         if (methods.FirstOrDefault(m => m.Name == "GetNewestFocusOrder") != null)
3150             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_newest_focus_order_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_newest_focus_order_get_static_delegate)});
3151         if (efl_ui_widget_focus_next_object_set_static_delegate == null)
3152             efl_ui_widget_focus_next_object_set_static_delegate = new efl_ui_widget_focus_next_object_set_delegate(focus_next_object_set);
3153         if (methods.FirstOrDefault(m => m.Name == "SetFocusNextObject") != null)
3154             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_object_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_object_set_static_delegate)});
3155         if (efl_ui_widget_focus_next_object_get_static_delegate == null)
3156             efl_ui_widget_focus_next_object_get_static_delegate = new efl_ui_widget_focus_next_object_get_delegate(focus_next_object_get);
3157         if (methods.FirstOrDefault(m => m.Name == "GetFocusNextObject") != null)
3158             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_object_get_static_delegate)});
3159         if (efl_ui_widget_focus_next_item_set_static_delegate == null)
3160             efl_ui_widget_focus_next_item_set_static_delegate = new efl_ui_widget_focus_next_item_set_delegate(focus_next_item_set);
3161         if (methods.FirstOrDefault(m => m.Name == "SetFocusNextItem") != null)
3162             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_item_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_item_set_static_delegate)});
3163         if (efl_ui_widget_focus_next_item_get_static_delegate == null)
3164             efl_ui_widget_focus_next_item_get_static_delegate = new efl_ui_widget_focus_next_item_get_delegate(focus_next_item_get);
3165         if (methods.FirstOrDefault(m => m.Name == "GetFocusNextItem") != null)
3166             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_item_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_item_get_static_delegate)});
3167         if (efl_ui_widget_focus_tree_unfocusable_handle_static_delegate == null)
3168             efl_ui_widget_focus_tree_unfocusable_handle_static_delegate = new efl_ui_widget_focus_tree_unfocusable_handle_delegate(focus_tree_unfocusable_handle);
3169         if (methods.FirstOrDefault(m => m.Name == "FocusTreeUnfocusableHandle") != null)
3170             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_tree_unfocusable_handle"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_tree_unfocusable_handle_static_delegate)});
3171         if (efl_ui_widget_focus_custom_chain_prepend_static_delegate == null)
3172             efl_ui_widget_focus_custom_chain_prepend_static_delegate = new efl_ui_widget_focus_custom_chain_prepend_delegate(focus_custom_chain_prepend);
3173         if (methods.FirstOrDefault(m => m.Name == "FocusCustomChainPrepend") != null)
3174             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_custom_chain_prepend"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_custom_chain_prepend_static_delegate)});
3175         if (efl_ui_widget_focus_cycle_static_delegate == null)
3176             efl_ui_widget_focus_cycle_static_delegate = new efl_ui_widget_focus_cycle_delegate(focus_cycle);
3177         if (methods.FirstOrDefault(m => m.Name == "FocusCycle") != null)
3178             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_cycle"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_cycle_static_delegate)});
3179         if (efl_ui_widget_focus_direction_static_delegate == null)
3180             efl_ui_widget_focus_direction_static_delegate = new efl_ui_widget_focus_direction_delegate(focus_direction);
3181         if (methods.FirstOrDefault(m => m.Name == "FocusDirection") != null)
3182             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_direction"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_direction_static_delegate)});
3183         if (efl_ui_widget_focus_next_manager_is_static_delegate == null)
3184             efl_ui_widget_focus_next_manager_is_static_delegate = new efl_ui_widget_focus_next_manager_is_delegate(focus_next_manager_is);
3185         if (methods.FirstOrDefault(m => m.Name == "IsFocusNextManager") != null)
3186             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_manager_is"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_manager_is_static_delegate)});
3187         if (efl_ui_widget_focus_list_direction_get_static_delegate == null)
3188             efl_ui_widget_focus_list_direction_get_static_delegate = new efl_ui_widget_focus_list_direction_get_delegate(focus_list_direction_get);
3189         if (methods.FirstOrDefault(m => m.Name == "GetFocusListDirection") != null)
3190             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_list_direction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_list_direction_get_static_delegate)});
3191         if (efl_ui_widget_focused_object_clear_static_delegate == null)
3192             efl_ui_widget_focused_object_clear_static_delegate = new efl_ui_widget_focused_object_clear_delegate(focused_object_clear);
3193         if (methods.FirstOrDefault(m => m.Name == "ClearFocusedObject") != null)
3194             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focused_object_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focused_object_clear_static_delegate)});
3195         if (efl_ui_widget_focus_direction_go_static_delegate == null)
3196             efl_ui_widget_focus_direction_go_static_delegate = new efl_ui_widget_focus_direction_go_delegate(focus_direction_go);
3197         if (methods.FirstOrDefault(m => m.Name == "FocusDirectionGo") != null)
3198             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_direction_go"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_direction_go_static_delegate)});
3199         if (efl_ui_widget_focus_next_get_static_delegate == null)
3200             efl_ui_widget_focus_next_get_static_delegate = new efl_ui_widget_focus_next_get_delegate(focus_next_get);
3201         if (methods.FirstOrDefault(m => m.Name == "GetFocusNext") != null)
3202             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_get_static_delegate)});
3203         if (efl_ui_widget_focus_restore_static_delegate == null)
3204             efl_ui_widget_focus_restore_static_delegate = new efl_ui_widget_focus_restore_delegate(focus_restore);
3205         if (methods.FirstOrDefault(m => m.Name == "FocusRestore") != null)
3206             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_restore"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_restore_static_delegate)});
3207         if (efl_ui_widget_focus_custom_chain_unset_static_delegate == null)
3208             efl_ui_widget_focus_custom_chain_unset_static_delegate = new efl_ui_widget_focus_custom_chain_unset_delegate(focus_custom_chain_unset);
3209         if (methods.FirstOrDefault(m => m.Name == "UnsetFocusCustomChain") != null)
3210             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_custom_chain_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_custom_chain_unset_static_delegate)});
3211         if (efl_ui_widget_focus_steal_static_delegate == null)
3212             efl_ui_widget_focus_steal_static_delegate = new efl_ui_widget_focus_steal_delegate(focus_steal);
3213         if (methods.FirstOrDefault(m => m.Name == "FocusSteal") != null)
3214             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_steal"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_steal_static_delegate)});
3215         if (efl_ui_widget_focus_hide_handle_static_delegate == null)
3216             efl_ui_widget_focus_hide_handle_static_delegate = new efl_ui_widget_focus_hide_handle_delegate(focus_hide_handle);
3217         if (methods.FirstOrDefault(m => m.Name == "FocusHideHandle") != null)
3218             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_hide_handle"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_hide_handle_static_delegate)});
3219         if (efl_ui_widget_focus_next_static_delegate == null)
3220             efl_ui_widget_focus_next_static_delegate = new efl_ui_widget_focus_next_delegate(focus_next);
3221         if (methods.FirstOrDefault(m => m.Name == "FocusNext") != null)
3222             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_next"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_next_static_delegate)});
3223         if (efl_ui_widget_focus_list_next_get_static_delegate == null)
3224             efl_ui_widget_focus_list_next_get_static_delegate = new efl_ui_widget_focus_list_next_get_delegate(focus_list_next_get);
3225         if (methods.FirstOrDefault(m => m.Name == "GetFocusListNext") != null)
3226             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_list_next_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_list_next_get_static_delegate)});
3227         if (efl_ui_widget_focus_mouse_up_handle_static_delegate == null)
3228             efl_ui_widget_focus_mouse_up_handle_static_delegate = new efl_ui_widget_focus_mouse_up_handle_delegate(focus_mouse_up_handle);
3229         if (methods.FirstOrDefault(m => m.Name == "FocusMouseUpHandle") != null)
3230             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_mouse_up_handle"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_mouse_up_handle_static_delegate)});
3231         if (efl_ui_widget_focus_direction_get_static_delegate == null)
3232             efl_ui_widget_focus_direction_get_static_delegate = new efl_ui_widget_focus_direction_get_delegate(focus_direction_get);
3233         if (methods.FirstOrDefault(m => m.Name == "GetFocusDirection") != null)
3234             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_direction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_direction_get_static_delegate)});
3235         if (efl_ui_widget_focus_disabled_handle_static_delegate == null)
3236             efl_ui_widget_focus_disabled_handle_static_delegate = new efl_ui_widget_focus_disabled_handle_delegate(focus_disabled_handle);
3237         if (methods.FirstOrDefault(m => m.Name == "FocusDisabledHandle") != null)
3238             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_disabled_handle"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_disabled_handle_static_delegate)});
3239         if (efl_ui_widget_focus_custom_chain_append_static_delegate == null)
3240             efl_ui_widget_focus_custom_chain_append_static_delegate = new efl_ui_widget_focus_custom_chain_append_delegate(focus_custom_chain_append);
3241         if (methods.FirstOrDefault(m => m.Name == "AppendFocusCustomChain") != null)
3242             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_custom_chain_append"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_custom_chain_append_static_delegate)});
3243         if (efl_ui_widget_focus_reconfigure_static_delegate == null)
3244             efl_ui_widget_focus_reconfigure_static_delegate = new efl_ui_widget_focus_reconfigure_delegate(focus_reconfigure);
3245         if (methods.FirstOrDefault(m => m.Name == "FocusReconfigure") != null)
3246             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_reconfigure"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_reconfigure_static_delegate)});
3247         if (efl_ui_widget_focus_direction_manager_is_static_delegate == null)
3248             efl_ui_widget_focus_direction_manager_is_static_delegate = new efl_ui_widget_focus_direction_manager_is_delegate(focus_direction_manager_is);
3249         if (methods.FirstOrDefault(m => m.Name == "IsFocusDirectionManager") != null)
3250             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_direction_manager_is"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_direction_manager_is_static_delegate)});
3251         if (efl_ui_widget_focus_state_apply_static_delegate == null)
3252             efl_ui_widget_focus_state_apply_static_delegate = new efl_ui_widget_focus_state_apply_delegate(focus_state_apply);
3253         if (methods.FirstOrDefault(m => m.Name == "FocusStateApply") != null)
3254             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_widget_focus_state_apply"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_state_apply_static_delegate)});
3255         if (efl_part_get_static_delegate == null)
3256             efl_part_get_static_delegate = new efl_part_get_delegate(part_get);
3257         if (methods.FirstOrDefault(m => m.Name == "GetPart") != null)
3258             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_part_get"), func = Marshal.GetFunctionPointerForDelegate(efl_part_get_static_delegate)});
3259         if (efl_access_action_name_get_static_delegate == null)
3260             efl_access_action_name_get_static_delegate = new efl_access_action_name_get_delegate(action_name_get);
3261         if (methods.FirstOrDefault(m => m.Name == "GetActionName") != null)
3262             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_action_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_action_name_get_static_delegate)});
3263         if (efl_access_action_localized_name_get_static_delegate == null)
3264             efl_access_action_localized_name_get_static_delegate = new efl_access_action_localized_name_get_delegate(action_localized_name_get);
3265         if (methods.FirstOrDefault(m => m.Name == "GetActionLocalizedName") != null)
3266             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_action_localized_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_action_localized_name_get_static_delegate)});
3267         if (efl_access_action_actions_get_static_delegate == null)
3268             efl_access_action_actions_get_static_delegate = new efl_access_action_actions_get_delegate(actions_get);
3269         if (methods.FirstOrDefault(m => m.Name == "GetActions") != null)
3270             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_action_actions_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_action_actions_get_static_delegate)});
3271         if (efl_access_action_do_static_delegate == null)
3272             efl_access_action_do_static_delegate = new efl_access_action_do_delegate(action_do);
3273         if (methods.FirstOrDefault(m => m.Name == "ActionDo") != null)
3274             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_action_do"), func = Marshal.GetFunctionPointerForDelegate(efl_access_action_do_static_delegate)});
3275         if (efl_access_action_keybinding_get_static_delegate == null)
3276             efl_access_action_keybinding_get_static_delegate = new efl_access_action_keybinding_get_delegate(action_keybinding_get);
3277         if (methods.FirstOrDefault(m => m.Name == "GetActionKeybinding") != null)
3278             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_action_keybinding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_action_keybinding_get_static_delegate)});
3279         if (efl_access_component_z_order_get_static_delegate == null)
3280             efl_access_component_z_order_get_static_delegate = new efl_access_component_z_order_get_delegate(z_order_get);
3281         if (methods.FirstOrDefault(m => m.Name == "GetZOrder") != null)
3282             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_z_order_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_z_order_get_static_delegate)});
3283         if (efl_access_component_extents_get_static_delegate == null)
3284             efl_access_component_extents_get_static_delegate = new efl_access_component_extents_get_delegate(extents_get);
3285         if (methods.FirstOrDefault(m => m.Name == "GetExtents") != null)
3286             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_extents_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_extents_get_static_delegate)});
3287         if (efl_access_component_extents_set_static_delegate == null)
3288             efl_access_component_extents_set_static_delegate = new efl_access_component_extents_set_delegate(extents_set);
3289         if (methods.FirstOrDefault(m => m.Name == "SetExtents") != null)
3290             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_extents_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_extents_set_static_delegate)});
3291         if (efl_access_component_screen_position_get_static_delegate == null)
3292             efl_access_component_screen_position_get_static_delegate = new efl_access_component_screen_position_get_delegate(screen_position_get);
3293         if (methods.FirstOrDefault(m => m.Name == "GetScreenPosition") != null)
3294             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_screen_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_screen_position_get_static_delegate)});
3295         if (efl_access_component_screen_position_set_static_delegate == null)
3296             efl_access_component_screen_position_set_static_delegate = new efl_access_component_screen_position_set_delegate(screen_position_set);
3297         if (methods.FirstOrDefault(m => m.Name == "SetScreenPosition") != null)
3298             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_screen_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_screen_position_set_static_delegate)});
3299         if (efl_access_component_socket_offset_get_static_delegate == null)
3300             efl_access_component_socket_offset_get_static_delegate = new efl_access_component_socket_offset_get_delegate(socket_offset_get);
3301         if (methods.FirstOrDefault(m => m.Name == "GetSocketOffset") != null)
3302             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_socket_offset_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_socket_offset_get_static_delegate)});
3303         if (efl_access_component_socket_offset_set_static_delegate == null)
3304             efl_access_component_socket_offset_set_static_delegate = new efl_access_component_socket_offset_set_delegate(socket_offset_set);
3305         if (methods.FirstOrDefault(m => m.Name == "SetSocketOffset") != null)
3306             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_socket_offset_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_socket_offset_set_static_delegate)});
3307         if (efl_access_component_contains_static_delegate == null)
3308             efl_access_component_contains_static_delegate = new efl_access_component_contains_delegate(contains);
3309         if (methods.FirstOrDefault(m => m.Name == "Contains") != null)
3310             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_contains"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_contains_static_delegate)});
3311         if (efl_access_component_focus_grab_static_delegate == null)
3312             efl_access_component_focus_grab_static_delegate = new efl_access_component_focus_grab_delegate(focus_grab);
3313         if (methods.FirstOrDefault(m => m.Name == "GrabFocus") != null)
3314             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_focus_grab"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_focus_grab_static_delegate)});
3315         if (efl_access_component_accessible_at_point_get_static_delegate == null)
3316             efl_access_component_accessible_at_point_get_static_delegate = new efl_access_component_accessible_at_point_get_delegate(accessible_at_point_get);
3317         if (methods.FirstOrDefault(m => m.Name == "GetAccessibleAtPoint") != null)
3318             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_accessible_at_point_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_accessible_at_point_get_static_delegate)});
3319         if (efl_access_component_highlight_grab_static_delegate == null)
3320             efl_access_component_highlight_grab_static_delegate = new efl_access_component_highlight_grab_delegate(highlight_grab);
3321         if (methods.FirstOrDefault(m => m.Name == "GrabHighlight") != null)
3322             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_highlight_grab"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_highlight_grab_static_delegate)});
3323         if (efl_access_component_highlight_clear_static_delegate == null)
3324             efl_access_component_highlight_clear_static_delegate = new efl_access_component_highlight_clear_delegate(highlight_clear);
3325         if (methods.FirstOrDefault(m => m.Name == "ClearHighlight") != null)
3326             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_component_highlight_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_access_component_highlight_clear_static_delegate)});
3327         if (efl_access_object_localized_role_name_get_static_delegate == null)
3328             efl_access_object_localized_role_name_get_static_delegate = new efl_access_object_localized_role_name_get_delegate(localized_role_name_get);
3329         if (methods.FirstOrDefault(m => m.Name == "GetLocalizedRoleName") != null)
3330             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_localized_role_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_localized_role_name_get_static_delegate)});
3331         if (efl_access_object_i18n_name_get_static_delegate == null)
3332             efl_access_object_i18n_name_get_static_delegate = new efl_access_object_i18n_name_get_delegate(i18n_name_get);
3333         if (methods.FirstOrDefault(m => m.Name == "GetI18nName") != null)
3334             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_i18n_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_i18n_name_get_static_delegate)});
3335         if (efl_access_object_i18n_name_set_static_delegate == null)
3336             efl_access_object_i18n_name_set_static_delegate = new efl_access_object_i18n_name_set_delegate(i18n_name_set);
3337         if (methods.FirstOrDefault(m => m.Name == "SetI18nName") != null)
3338             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_i18n_name_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_i18n_name_set_static_delegate)});
3339         if (efl_access_object_name_cb_set_static_delegate == null)
3340             efl_access_object_name_cb_set_static_delegate = new efl_access_object_name_cb_set_delegate(name_cb_set);
3341         if (methods.FirstOrDefault(m => m.Name == "SetNameCb") != null)
3342             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_name_cb_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_name_cb_set_static_delegate)});
3343         if (efl_access_object_relation_set_get_static_delegate == null)
3344             efl_access_object_relation_set_get_static_delegate = new efl_access_object_relation_set_get_delegate(relation_set_get);
3345         if (methods.FirstOrDefault(m => m.Name == "GetRelationSet") != null)
3346             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_relation_set_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_relation_set_get_static_delegate)});
3347         if (efl_access_object_role_get_static_delegate == null)
3348             efl_access_object_role_get_static_delegate = new efl_access_object_role_get_delegate(role_get);
3349         if (methods.FirstOrDefault(m => m.Name == "GetRole") != null)
3350             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_role_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_role_get_static_delegate)});
3351         if (efl_access_object_role_set_static_delegate == null)
3352             efl_access_object_role_set_static_delegate = new efl_access_object_role_set_delegate(role_set);
3353         if (methods.FirstOrDefault(m => m.Name == "SetRole") != null)
3354             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_role_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_role_set_static_delegate)});
3355         if (efl_access_object_access_parent_get_static_delegate == null)
3356             efl_access_object_access_parent_get_static_delegate = new efl_access_object_access_parent_get_delegate(access_parent_get);
3357         if (methods.FirstOrDefault(m => m.Name == "GetAccessParent") != null)
3358             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_access_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_access_parent_get_static_delegate)});
3359         if (efl_access_object_access_parent_set_static_delegate == null)
3360             efl_access_object_access_parent_set_static_delegate = new efl_access_object_access_parent_set_delegate(access_parent_set);
3361         if (methods.FirstOrDefault(m => m.Name == "SetAccessParent") != null)
3362             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_access_parent_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_access_parent_set_static_delegate)});
3363         if (efl_access_object_description_cb_set_static_delegate == null)
3364             efl_access_object_description_cb_set_static_delegate = new efl_access_object_description_cb_set_delegate(description_cb_set);
3365         if (methods.FirstOrDefault(m => m.Name == "SetDescriptionCb") != null)
3366             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_description_cb_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_description_cb_set_static_delegate)});
3367         if (efl_access_object_gesture_cb_set_static_delegate == null)
3368             efl_access_object_gesture_cb_set_static_delegate = new efl_access_object_gesture_cb_set_delegate(gesture_cb_set);
3369         if (methods.FirstOrDefault(m => m.Name == "SetGestureCb") != null)
3370             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_gesture_cb_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_gesture_cb_set_static_delegate)});
3371         if (efl_access_object_access_children_get_static_delegate == null)
3372             efl_access_object_access_children_get_static_delegate = new efl_access_object_access_children_get_delegate(access_children_get);
3373         if (methods.FirstOrDefault(m => m.Name == "GetAccessChildren") != null)
3374             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_access_children_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_access_children_get_static_delegate)});
3375         if (efl_access_object_role_name_get_static_delegate == null)
3376             efl_access_object_role_name_get_static_delegate = new efl_access_object_role_name_get_delegate(role_name_get);
3377         if (methods.FirstOrDefault(m => m.Name == "GetRoleName") != null)
3378             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_role_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_role_name_get_static_delegate)});
3379         if (efl_access_object_attributes_get_static_delegate == null)
3380             efl_access_object_attributes_get_static_delegate = new efl_access_object_attributes_get_delegate(attributes_get);
3381         if (methods.FirstOrDefault(m => m.Name == "GetAttributes") != null)
3382             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_attributes_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_attributes_get_static_delegate)});
3383         if (efl_access_object_reading_info_type_get_static_delegate == null)
3384             efl_access_object_reading_info_type_get_static_delegate = new efl_access_object_reading_info_type_get_delegate(reading_info_type_get);
3385         if (methods.FirstOrDefault(m => m.Name == "GetReadingInfoType") != null)
3386             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_reading_info_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_reading_info_type_get_static_delegate)});
3387         if (efl_access_object_reading_info_type_set_static_delegate == null)
3388             efl_access_object_reading_info_type_set_static_delegate = new efl_access_object_reading_info_type_set_delegate(reading_info_type_set);
3389         if (methods.FirstOrDefault(m => m.Name == "SetReadingInfoType") != null)
3390             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_reading_info_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_reading_info_type_set_static_delegate)});
3391         if (efl_access_object_index_in_parent_get_static_delegate == null)
3392             efl_access_object_index_in_parent_get_static_delegate = new efl_access_object_index_in_parent_get_delegate(index_in_parent_get);
3393         if (methods.FirstOrDefault(m => m.Name == "GetIndexInParent") != null)
3394             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_index_in_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_index_in_parent_get_static_delegate)});
3395         if (efl_access_object_description_get_static_delegate == null)
3396             efl_access_object_description_get_static_delegate = new efl_access_object_description_get_delegate(description_get);
3397         if (methods.FirstOrDefault(m => m.Name == "GetDescription") != null)
3398             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_description_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_description_get_static_delegate)});
3399         if (efl_access_object_description_set_static_delegate == null)
3400             efl_access_object_description_set_static_delegate = new efl_access_object_description_set_delegate(description_set);
3401         if (methods.FirstOrDefault(m => m.Name == "SetDescription") != null)
3402             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_description_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_description_set_static_delegate)});
3403         if (efl_access_object_state_set_get_static_delegate == null)
3404             efl_access_object_state_set_get_static_delegate = new efl_access_object_state_set_get_delegate(state_set_get);
3405         if (methods.FirstOrDefault(m => m.Name == "GetStateSet") != null)
3406             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_state_set_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_state_set_get_static_delegate)});
3407         if (efl_access_object_can_highlight_get_static_delegate == null)
3408             efl_access_object_can_highlight_get_static_delegate = new efl_access_object_can_highlight_get_delegate(can_highlight_get);
3409         if (methods.FirstOrDefault(m => m.Name == "GetCanHighlight") != null)
3410             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_can_highlight_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_can_highlight_get_static_delegate)});
3411         if (efl_access_object_can_highlight_set_static_delegate == null)
3412             efl_access_object_can_highlight_set_static_delegate = new efl_access_object_can_highlight_set_delegate(can_highlight_set);
3413         if (methods.FirstOrDefault(m => m.Name == "SetCanHighlight") != null)
3414             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_can_highlight_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_can_highlight_set_static_delegate)});
3415         if (efl_access_object_translation_domain_get_static_delegate == null)
3416             efl_access_object_translation_domain_get_static_delegate = new efl_access_object_translation_domain_get_delegate(translation_domain_get);
3417         if (methods.FirstOrDefault(m => m.Name == "GetTranslationDomain") != null)
3418             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_translation_domain_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_translation_domain_get_static_delegate)});
3419         if (efl_access_object_translation_domain_set_static_delegate == null)
3420             efl_access_object_translation_domain_set_static_delegate = new efl_access_object_translation_domain_set_delegate(translation_domain_set);
3421         if (methods.FirstOrDefault(m => m.Name == "SetTranslationDomain") != null)
3422             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_translation_domain_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_translation_domain_set_static_delegate)});
3423         if (efl_access_object_gesture_do_static_delegate == null)
3424             efl_access_object_gesture_do_static_delegate = new efl_access_object_gesture_do_delegate(gesture_do);
3425         if (methods.FirstOrDefault(m => m.Name == "GestureDo") != null)
3426             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_gesture_do"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_gesture_do_static_delegate)});
3427         if (efl_access_object_attribute_append_static_delegate == null)
3428             efl_access_object_attribute_append_static_delegate = new efl_access_object_attribute_append_delegate(attribute_append);
3429         if (methods.FirstOrDefault(m => m.Name == "AppendAttribute") != null)
3430             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_attribute_append"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_attribute_append_static_delegate)});
3431         if (efl_access_object_attribute_del_static_delegate == null)
3432             efl_access_object_attribute_del_static_delegate = new efl_access_object_attribute_del_delegate(attribute_del);
3433         if (methods.FirstOrDefault(m => m.Name == "DelAttribute") != null)
3434             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_attribute_del"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_attribute_del_static_delegate)});
3435         if (efl_access_object_attributes_clear_static_delegate == null)
3436             efl_access_object_attributes_clear_static_delegate = new efl_access_object_attributes_clear_delegate(attributes_clear);
3437         if (methods.FirstOrDefault(m => m.Name == "ClearAttributes") != null)
3438             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_attributes_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_attributes_clear_static_delegate)});
3439         if (efl_access_object_relationship_append_static_delegate == null)
3440             efl_access_object_relationship_append_static_delegate = new efl_access_object_relationship_append_delegate(relationship_append);
3441         if (methods.FirstOrDefault(m => m.Name == "AppendRelationship") != null)
3442             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_relationship_append"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_relationship_append_static_delegate)});
3443         if (efl_access_object_relationship_remove_static_delegate == null)
3444             efl_access_object_relationship_remove_static_delegate = new efl_access_object_relationship_remove_delegate(relationship_remove);
3445         if (methods.FirstOrDefault(m => m.Name == "RelationshipRemove") != null)
3446             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_relationship_remove"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_relationship_remove_static_delegate)});
3447         if (efl_access_object_relationships_clear_static_delegate == null)
3448             efl_access_object_relationships_clear_static_delegate = new efl_access_object_relationships_clear_delegate(relationships_clear);
3449         if (methods.FirstOrDefault(m => m.Name == "ClearRelationships") != null)
3450             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_relationships_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_relationships_clear_static_delegate)});
3451         if (efl_access_object_state_notify_static_delegate == null)
3452             efl_access_object_state_notify_static_delegate = new efl_access_object_state_notify_delegate(state_notify);
3453         if (methods.FirstOrDefault(m => m.Name == "StateNotify") != null)
3454             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_object_state_notify"), func = Marshal.GetFunctionPointerForDelegate(efl_access_object_state_notify_static_delegate)});
3455         if (efl_access_widget_action_elm_actions_get_static_delegate == null)
3456             efl_access_widget_action_elm_actions_get_static_delegate = new efl_access_widget_action_elm_actions_get_delegate(elm_actions_get);
3457         if (methods.FirstOrDefault(m => m.Name == "GetElmActions") != null)
3458             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_access_widget_action_elm_actions_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_widget_action_elm_actions_get_static_delegate)});
3459         if (efl_ui_dnd_drag_start_static_delegate == null)
3460             efl_ui_dnd_drag_start_static_delegate = new efl_ui_dnd_drag_start_delegate(drag_start);
3461         if (methods.FirstOrDefault(m => m.Name == "DragStart") != null)
3462             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_dnd_drag_start"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_dnd_drag_start_static_delegate)});
3463         if (efl_ui_dnd_drag_action_set_static_delegate == null)
3464             efl_ui_dnd_drag_action_set_static_delegate = new efl_ui_dnd_drag_action_set_delegate(drag_action_set);
3465         if (methods.FirstOrDefault(m => m.Name == "SetDragAction") != null)
3466             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_dnd_drag_action_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_dnd_drag_action_set_static_delegate)});
3467         if (efl_ui_dnd_drag_cancel_static_delegate == null)
3468             efl_ui_dnd_drag_cancel_static_delegate = new efl_ui_dnd_drag_cancel_delegate(drag_cancel);
3469         if (methods.FirstOrDefault(m => m.Name == "DragCancel") != null)
3470             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_dnd_drag_cancel"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_dnd_drag_cancel_static_delegate)});
3471         if (efl_ui_dnd_drop_target_add_static_delegate == null)
3472             efl_ui_dnd_drop_target_add_static_delegate = new efl_ui_dnd_drop_target_add_delegate(drop_target_add);
3473         if (methods.FirstOrDefault(m => m.Name == "AddDropTarget") != null)
3474             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_dnd_drop_target_add"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_dnd_drop_target_add_static_delegate)});
3475         if (efl_ui_dnd_drop_target_del_static_delegate == null)
3476             efl_ui_dnd_drop_target_del_static_delegate = new efl_ui_dnd_drop_target_del_delegate(drop_target_del);
3477         if (methods.FirstOrDefault(m => m.Name == "DelDropTarget") != null)
3478             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_dnd_drop_target_del"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_dnd_drop_target_del_static_delegate)});
3479         if (efl_ui_l10n_text_get_static_delegate == null)
3480             efl_ui_l10n_text_get_static_delegate = new efl_ui_l10n_text_get_delegate(l10n_text_get);
3481         if (methods.FirstOrDefault(m => m.Name == "GetL10nText") != null)
3482             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_l10n_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_text_get_static_delegate)});
3483         if (efl_ui_l10n_text_set_static_delegate == null)
3484             efl_ui_l10n_text_set_static_delegate = new efl_ui_l10n_text_set_delegate(l10n_text_set);
3485         if (methods.FirstOrDefault(m => m.Name == "SetL10nText") != null)
3486             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_l10n_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_text_set_static_delegate)});
3487         if (efl_ui_l10n_translation_update_static_delegate == null)
3488             efl_ui_l10n_translation_update_static_delegate = new efl_ui_l10n_translation_update_delegate(translation_update);
3489         if (methods.FirstOrDefault(m => m.Name == "UpdateTranslation") != null)
3490             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_l10n_translation_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_translation_update_static_delegate)});
3491         if (efl_ui_property_bind_static_delegate == null)
3492             efl_ui_property_bind_static_delegate = new efl_ui_property_bind_delegate(property_bind);
3493         if (methods.FirstOrDefault(m => m.Name == "PropertyBind") != null)
3494             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_property_bind"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_property_bind_static_delegate)});
3495         if (efl_ui_selection_set_static_delegate == null)
3496             efl_ui_selection_set_static_delegate = new efl_ui_selection_set_delegate(selection_set);
3497         if (methods.FirstOrDefault(m => m.Name == "SetSelection") != null)
3498             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_selection_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_selection_set_static_delegate)});
3499         if (efl_ui_selection_get_static_delegate == null)
3500             efl_ui_selection_get_static_delegate = new efl_ui_selection_get_delegate(selection_get);
3501         if (methods.FirstOrDefault(m => m.Name == "GetSelection") != null)
3502             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_selection_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_selection_get_static_delegate)});
3503         if (efl_ui_selection_clear_static_delegate == null)
3504             efl_ui_selection_clear_static_delegate = new efl_ui_selection_clear_delegate(selection_clear);
3505         if (methods.FirstOrDefault(m => m.Name == "ClearSelection") != null)
3506             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_selection_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_selection_clear_static_delegate)});
3507         if (efl_ui_selection_has_owner_static_delegate == null)
3508             efl_ui_selection_has_owner_static_delegate = new efl_ui_selection_has_owner_delegate(has_owner);
3509         if (methods.FirstOrDefault(m => m.Name == "HasOwner") != null)
3510             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_selection_has_owner"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_selection_has_owner_static_delegate)});
3511         if (efl_ui_view_model_get_static_delegate == null)
3512             efl_ui_view_model_get_static_delegate = new efl_ui_view_model_get_delegate(model_get);
3513         if (methods.FirstOrDefault(m => m.Name == "GetModel") != null)
3514             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_view_model_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_view_model_get_static_delegate)});
3515         if (efl_ui_view_model_set_static_delegate == null)
3516             efl_ui_view_model_set_static_delegate = new efl_ui_view_model_set_delegate(model_set);
3517         if (methods.FirstOrDefault(m => m.Name == "SetModel") != null)
3518             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_view_model_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_view_model_set_static_delegate)});
3519         if (efl_ui_focus_object_focus_geometry_get_static_delegate == null)
3520             efl_ui_focus_object_focus_geometry_get_static_delegate = new efl_ui_focus_object_focus_geometry_get_delegate(focus_geometry_get);
3521         if (methods.FirstOrDefault(m => m.Name == "GetFocusGeometry") != null)
3522             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_geometry_get_static_delegate)});
3523         if (efl_ui_focus_object_focus_get_static_delegate == null)
3524             efl_ui_focus_object_focus_get_static_delegate = new efl_ui_focus_object_focus_get_delegate(focus_get);
3525         if (methods.FirstOrDefault(m => m.Name == "GetFocus") != null)
3526             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_get_static_delegate)});
3527         if (efl_ui_focus_object_focus_set_static_delegate == null)
3528             efl_ui_focus_object_focus_set_static_delegate = new efl_ui_focus_object_focus_set_delegate(focus_set);
3529         if (methods.FirstOrDefault(m => m.Name == "SetFocus") != null)
3530             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_set_static_delegate)});
3531         if (efl_ui_focus_object_focus_manager_get_static_delegate == null)
3532             efl_ui_focus_object_focus_manager_get_static_delegate = new efl_ui_focus_object_focus_manager_get_delegate(focus_manager_get);
3533         if (methods.FirstOrDefault(m => m.Name == "GetFocusManager") != null)
3534             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_manager_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_manager_get_static_delegate)});
3535         if (efl_ui_focus_object_focus_parent_get_static_delegate == null)
3536             efl_ui_focus_object_focus_parent_get_static_delegate = new efl_ui_focus_object_focus_parent_get_delegate(focus_parent_get);
3537         if (methods.FirstOrDefault(m => m.Name == "GetFocusParent") != null)
3538             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_focus_parent_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_focus_parent_get_static_delegate)});
3539         if (efl_ui_focus_object_child_focus_get_static_delegate == null)
3540             efl_ui_focus_object_child_focus_get_static_delegate = new efl_ui_focus_object_child_focus_get_delegate(child_focus_get);
3541         if (methods.FirstOrDefault(m => m.Name == "GetChildFocus") != null)
3542             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_child_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_child_focus_get_static_delegate)});
3543         if (efl_ui_focus_object_child_focus_set_static_delegate == null)
3544             efl_ui_focus_object_child_focus_set_static_delegate = new efl_ui_focus_object_child_focus_set_delegate(child_focus_set);
3545         if (methods.FirstOrDefault(m => m.Name == "SetChildFocus") != null)
3546             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_child_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_child_focus_set_static_delegate)});
3547         if (efl_ui_focus_object_setup_order_static_delegate == null)
3548             efl_ui_focus_object_setup_order_static_delegate = new efl_ui_focus_object_setup_order_delegate(setup_order);
3549         if (methods.FirstOrDefault(m => m.Name == "SetupOrder") != null)
3550             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_setup_order"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_setup_order_static_delegate)});
3551         if (efl_ui_focus_object_setup_order_non_recursive_static_delegate == null)
3552             efl_ui_focus_object_setup_order_non_recursive_static_delegate = new efl_ui_focus_object_setup_order_non_recursive_delegate(setup_order_non_recursive);
3553         if (methods.FirstOrDefault(m => m.Name == "SetupOrderNonRecursive") != null)
3554             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_setup_order_non_recursive"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_setup_order_non_recursive_static_delegate)});
3555         if (efl_ui_focus_object_on_focus_update_static_delegate == null)
3556             efl_ui_focus_object_on_focus_update_static_delegate = new efl_ui_focus_object_on_focus_update_delegate(on_focus_update);
3557         if (methods.FirstOrDefault(m => m.Name == "UpdateOnFocus") != null)
3558             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_focus_object_on_focus_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_object_on_focus_update_static_delegate)});
3559         descs.AddRange(base.GetEoOps(type));
3560         return descs;
3561     }
3562     public override IntPtr GetEflClass()
3563     {
3564         return Efl.Ui.Widget.efl_ui_widget_class_get();
3565     }
3566     public static new  IntPtr GetEflClassStatic()
3567     {
3568         return Efl.Ui.Widget.efl_ui_widget_class_get();
3569     }
3570
3571
3572      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_widget_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd);
3573
3574
3575      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_widget_cursor_get_api_delegate(System.IntPtr obj);
3576      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_get_api_delegate> efl_ui_widget_cursor_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_get_api_delegate>(_Module, "efl_ui_widget_cursor_get");
3577      private static System.String cursor_get(System.IntPtr obj, System.IntPtr pd)
3578     {
3579         Eina.Log.Debug("function efl_ui_widget_cursor_get was called");
3580         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3581         if(wrapper != null) {
3582                         System.String _ret_var = default(System.String);
3583             try {
3584                 _ret_var = ((Widget)wrapper).GetCursor();
3585             } catch (Exception e) {
3586                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3587                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3588             }
3589         return _ret_var;
3590         } else {
3591             return efl_ui_widget_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3592         }
3593     }
3594     private static efl_ui_widget_cursor_get_delegate efl_ui_widget_cursor_get_static_delegate;
3595
3596
3597      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_cursor_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String cursor);
3598
3599
3600      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_cursor_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String cursor);
3601      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_set_api_delegate> efl_ui_widget_cursor_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_set_api_delegate>(_Module, "efl_ui_widget_cursor_set");
3602      private static bool cursor_set(System.IntPtr obj, System.IntPtr pd,  System.String cursor)
3603     {
3604         Eina.Log.Debug("function efl_ui_widget_cursor_set was called");
3605         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3606         if(wrapper != null) {
3607                                                 bool _ret_var = default(bool);
3608             try {
3609                 _ret_var = ((Widget)wrapper).SetCursor( cursor);
3610             } catch (Exception e) {
3611                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3612                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3613             }
3614                         return _ret_var;
3615         } else {
3616             return efl_ui_widget_cursor_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cursor);
3617         }
3618     }
3619     private static efl_ui_widget_cursor_set_delegate efl_ui_widget_cursor_set_static_delegate;
3620
3621
3622      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_widget_cursor_style_get_delegate(System.IntPtr obj, System.IntPtr pd);
3623
3624
3625      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_widget_cursor_style_get_api_delegate(System.IntPtr obj);
3626      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_style_get_api_delegate> efl_ui_widget_cursor_style_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_style_get_api_delegate>(_Module, "efl_ui_widget_cursor_style_get");
3627      private static System.String cursor_style_get(System.IntPtr obj, System.IntPtr pd)
3628     {
3629         Eina.Log.Debug("function efl_ui_widget_cursor_style_get was called");
3630         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3631         if(wrapper != null) {
3632                         System.String _ret_var = default(System.String);
3633             try {
3634                 _ret_var = ((Widget)wrapper).GetCursorStyle();
3635             } catch (Exception e) {
3636                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3637                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3638             }
3639         return _ret_var;
3640         } else {
3641             return efl_ui_widget_cursor_style_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3642         }
3643     }
3644     private static efl_ui_widget_cursor_style_get_delegate efl_ui_widget_cursor_style_get_static_delegate;
3645
3646
3647      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_cursor_style_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String style);
3648
3649
3650      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_cursor_style_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String style);
3651      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_style_set_api_delegate> efl_ui_widget_cursor_style_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_style_set_api_delegate>(_Module, "efl_ui_widget_cursor_style_set");
3652      private static bool cursor_style_set(System.IntPtr obj, System.IntPtr pd,  System.String style)
3653     {
3654         Eina.Log.Debug("function efl_ui_widget_cursor_style_set was called");
3655         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3656         if(wrapper != null) {
3657                                                 bool _ret_var = default(bool);
3658             try {
3659                 _ret_var = ((Widget)wrapper).SetCursorStyle( style);
3660             } catch (Exception e) {
3661                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3662                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3663             }
3664                         return _ret_var;
3665         } else {
3666             return efl_ui_widget_cursor_style_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  style);
3667         }
3668     }
3669     private static efl_ui_widget_cursor_style_set_delegate efl_ui_widget_cursor_style_set_static_delegate;
3670
3671
3672      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_cursor_theme_search_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd);
3673
3674
3675      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_cursor_theme_search_enabled_get_api_delegate(System.IntPtr obj);
3676      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_theme_search_enabled_get_api_delegate> efl_ui_widget_cursor_theme_search_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_theme_search_enabled_get_api_delegate>(_Module, "efl_ui_widget_cursor_theme_search_enabled_get");
3677      private static bool cursor_theme_search_enabled_get(System.IntPtr obj, System.IntPtr pd)
3678     {
3679         Eina.Log.Debug("function efl_ui_widget_cursor_theme_search_enabled_get was called");
3680         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3681         if(wrapper != null) {
3682                         bool _ret_var = default(bool);
3683             try {
3684                 _ret_var = ((Widget)wrapper).GetCursorThemeSearchEnabled();
3685             } catch (Exception e) {
3686                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3687                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3688             }
3689         return _ret_var;
3690         } else {
3691             return efl_ui_widget_cursor_theme_search_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3692         }
3693     }
3694     private static efl_ui_widget_cursor_theme_search_enabled_get_delegate efl_ui_widget_cursor_theme_search_enabled_get_static_delegate;
3695
3696
3697      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_cursor_theme_search_enabled_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool allow);
3698
3699
3700      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_cursor_theme_search_enabled_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool allow);
3701      public static Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_theme_search_enabled_set_api_delegate> efl_ui_widget_cursor_theme_search_enabled_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_cursor_theme_search_enabled_set_api_delegate>(_Module, "efl_ui_widget_cursor_theme_search_enabled_set");
3702      private static bool cursor_theme_search_enabled_set(System.IntPtr obj, System.IntPtr pd,  bool allow)
3703     {
3704         Eina.Log.Debug("function efl_ui_widget_cursor_theme_search_enabled_set was called");
3705         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3706         if(wrapper != null) {
3707                                                 bool _ret_var = default(bool);
3708             try {
3709                 _ret_var = ((Widget)wrapper).SetCursorThemeSearchEnabled( allow);
3710             } catch (Exception e) {
3711                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3712                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3713             }
3714                         return _ret_var;
3715         } else {
3716             return efl_ui_widget_cursor_theme_search_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  allow);
3717         }
3718     }
3719     private static efl_ui_widget_cursor_theme_search_enabled_set_delegate efl_ui_widget_cursor_theme_search_enabled_set_static_delegate;
3720
3721
3722      private delegate void efl_ui_widget_resize_object_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sobj);
3723
3724
3725      public delegate void efl_ui_widget_resize_object_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sobj);
3726      public static Efl.Eo.FunctionWrapper<efl_ui_widget_resize_object_set_api_delegate> efl_ui_widget_resize_object_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_resize_object_set_api_delegate>(_Module, "efl_ui_widget_resize_object_set");
3727      private static void resize_object_set(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sobj)
3728     {
3729         Eina.Log.Debug("function efl_ui_widget_resize_object_set was called");
3730         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3731         if(wrapper != null) {
3732
3733             try {
3734                 ((Widget)wrapper).SetResizeObject( sobj);
3735             } catch (Exception e) {
3736                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3737                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3738             }
3739                                 } else {
3740             efl_ui_widget_resize_object_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sobj);
3741         }
3742     }
3743     private static efl_ui_widget_resize_object_set_delegate efl_ui_widget_resize_object_set_static_delegate;
3744
3745
3746      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_disabled_get_delegate(System.IntPtr obj, System.IntPtr pd);
3747
3748
3749      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_disabled_get_api_delegate(System.IntPtr obj);
3750      public static Efl.Eo.FunctionWrapper<efl_ui_widget_disabled_get_api_delegate> efl_ui_widget_disabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_disabled_get_api_delegate>(_Module, "efl_ui_widget_disabled_get");
3751      private static bool disabled_get(System.IntPtr obj, System.IntPtr pd)
3752     {
3753         Eina.Log.Debug("function efl_ui_widget_disabled_get was called");
3754         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3755         if(wrapper != null) {
3756                         bool _ret_var = default(bool);
3757             try {
3758                 _ret_var = ((Widget)wrapper).GetDisabled();
3759             } catch (Exception e) {
3760                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3761                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3762             }
3763         return _ret_var;
3764         } else {
3765             return efl_ui_widget_disabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3766         }
3767     }
3768     private static efl_ui_widget_disabled_get_delegate efl_ui_widget_disabled_get_static_delegate;
3769
3770
3771      private delegate void efl_ui_widget_disabled_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool disabled);
3772
3773
3774      public delegate void efl_ui_widget_disabled_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool disabled);
3775      public static Efl.Eo.FunctionWrapper<efl_ui_widget_disabled_set_api_delegate> efl_ui_widget_disabled_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_disabled_set_api_delegate>(_Module, "efl_ui_widget_disabled_set");
3776      private static void disabled_set(System.IntPtr obj, System.IntPtr pd,  bool disabled)
3777     {
3778         Eina.Log.Debug("function efl_ui_widget_disabled_set was called");
3779         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3780         if(wrapper != null) {
3781
3782             try {
3783                 ((Widget)wrapper).SetDisabled( disabled);
3784             } catch (Exception e) {
3785                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3786                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3787             }
3788                                 } else {
3789             efl_ui_widget_disabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  disabled);
3790         }
3791     }
3792     private static efl_ui_widget_disabled_set_delegate efl_ui_widget_disabled_set_static_delegate;
3793
3794
3795      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_widget_style_get_delegate(System.IntPtr obj, System.IntPtr pd);
3796
3797
3798      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_widget_style_get_api_delegate(System.IntPtr obj);
3799      public static Efl.Eo.FunctionWrapper<efl_ui_widget_style_get_api_delegate> efl_ui_widget_style_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_style_get_api_delegate>(_Module, "efl_ui_widget_style_get");
3800      private static System.String style_get(System.IntPtr obj, System.IntPtr pd)
3801     {
3802         Eina.Log.Debug("function efl_ui_widget_style_get was called");
3803         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3804         if(wrapper != null) {
3805                         System.String _ret_var = default(System.String);
3806             try {
3807                 _ret_var = ((Widget)wrapper).GetStyle();
3808             } catch (Exception e) {
3809                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3810                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3811             }
3812         return _ret_var;
3813         } else {
3814             return efl_ui_widget_style_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3815         }
3816     }
3817     private static efl_ui_widget_style_get_delegate efl_ui_widget_style_get_static_delegate;
3818
3819
3820      private delegate Eina.Error efl_ui_widget_style_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String style);
3821
3822
3823      public delegate Eina.Error efl_ui_widget_style_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String style);
3824      public static Efl.Eo.FunctionWrapper<efl_ui_widget_style_set_api_delegate> efl_ui_widget_style_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_style_set_api_delegate>(_Module, "efl_ui_widget_style_set");
3825      private static Eina.Error style_set(System.IntPtr obj, System.IntPtr pd,  System.String style)
3826     {
3827         Eina.Log.Debug("function efl_ui_widget_style_set was called");
3828         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3829         if(wrapper != null) {
3830                                                 Eina.Error _ret_var = default(Eina.Error);
3831             try {
3832                 _ret_var = ((Widget)wrapper).SetStyle( style);
3833             } catch (Exception e) {
3834                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3835                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3836             }
3837                         return _ret_var;
3838         } else {
3839             return efl_ui_widget_style_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  style);
3840         }
3841     }
3842     private static efl_ui_widget_style_set_delegate efl_ui_widget_style_set_static_delegate;
3843
3844
3845      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_allow_get_delegate(System.IntPtr obj, System.IntPtr pd);
3846
3847
3848      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_allow_get_api_delegate(System.IntPtr obj);
3849      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_allow_get_api_delegate> efl_ui_widget_focus_allow_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_allow_get_api_delegate>(_Module, "efl_ui_widget_focus_allow_get");
3850      private static bool focus_allow_get(System.IntPtr obj, System.IntPtr pd)
3851     {
3852         Eina.Log.Debug("function efl_ui_widget_focus_allow_get was called");
3853         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3854         if(wrapper != null) {
3855                         bool _ret_var = default(bool);
3856             try {
3857                 _ret_var = ((Widget)wrapper).GetFocusAllow();
3858             } catch (Exception e) {
3859                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3860                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3861             }
3862         return _ret_var;
3863         } else {
3864             return efl_ui_widget_focus_allow_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3865         }
3866     }
3867     private static efl_ui_widget_focus_allow_get_delegate efl_ui_widget_focus_allow_get_static_delegate;
3868
3869
3870      private delegate void efl_ui_widget_focus_allow_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool can_focus);
3871
3872
3873      public delegate void efl_ui_widget_focus_allow_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool can_focus);
3874      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_allow_set_api_delegate> efl_ui_widget_focus_allow_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_allow_set_api_delegate>(_Module, "efl_ui_widget_focus_allow_set");
3875      private static void focus_allow_set(System.IntPtr obj, System.IntPtr pd,  bool can_focus)
3876     {
3877         Eina.Log.Debug("function efl_ui_widget_focus_allow_set was called");
3878         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3879         if(wrapper != null) {
3880
3881             try {
3882                 ((Widget)wrapper).SetFocusAllow( can_focus);
3883             } catch (Exception e) {
3884                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3885                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3886             }
3887                                 } else {
3888             efl_ui_widget_focus_allow_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  can_focus);
3889         }
3890     }
3891     private static efl_ui_widget_focus_allow_set_delegate efl_ui_widget_focus_allow_set_static_delegate;
3892
3893
3894     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Widget efl_ui_widget_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
3895
3896
3897     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Widget efl_ui_widget_parent_get_api_delegate(System.IntPtr obj);
3898      public static Efl.Eo.FunctionWrapper<efl_ui_widget_parent_get_api_delegate> efl_ui_widget_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_parent_get_api_delegate>(_Module, "efl_ui_widget_parent_get");
3899      private static Efl.Ui.Widget widget_parent_get(System.IntPtr obj, System.IntPtr pd)
3900     {
3901         Eina.Log.Debug("function efl_ui_widget_parent_get was called");
3902         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3903         if(wrapper != null) {
3904                         Efl.Ui.Widget _ret_var = default(Efl.Ui.Widget);
3905             try {
3906                 _ret_var = ((Widget)wrapper).GetWidgetParent();
3907             } catch (Exception e) {
3908                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3909                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3910             }
3911         return _ret_var;
3912         } else {
3913             return efl_ui_widget_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3914         }
3915     }
3916     private static efl_ui_widget_parent_get_delegate efl_ui_widget_parent_get_static_delegate;
3917
3918
3919      private delegate void efl_ui_widget_parent_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget parent);
3920
3921
3922      public delegate void efl_ui_widget_parent_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget parent);
3923      public static Efl.Eo.FunctionWrapper<efl_ui_widget_parent_set_api_delegate> efl_ui_widget_parent_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_parent_set_api_delegate>(_Module, "efl_ui_widget_parent_set");
3924      private static void widget_parent_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Widget parent)
3925     {
3926         Eina.Log.Debug("function efl_ui_widget_parent_set was called");
3927         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3928         if(wrapper != null) {
3929
3930             try {
3931                 ((Widget)wrapper).SetWidgetParent( parent);
3932             } catch (Exception e) {
3933                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3934                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3935             }
3936                                 } else {
3937             efl_ui_widget_parent_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  parent);
3938         }
3939     }
3940     private static efl_ui_widget_parent_set_delegate efl_ui_widget_parent_set_static_delegate;
3941
3942
3943      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_widget_access_info_get_delegate(System.IntPtr obj, System.IntPtr pd);
3944
3945
3946      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_widget_access_info_get_api_delegate(System.IntPtr obj);
3947      public static Efl.Eo.FunctionWrapper<efl_ui_widget_access_info_get_api_delegate> efl_ui_widget_access_info_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_access_info_get_api_delegate>(_Module, "efl_ui_widget_access_info_get");
3948      private static System.String access_info_get(System.IntPtr obj, System.IntPtr pd)
3949     {
3950         Eina.Log.Debug("function efl_ui_widget_access_info_get was called");
3951         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3952         if(wrapper != null) {
3953                         System.String _ret_var = default(System.String);
3954             try {
3955                 _ret_var = ((Widget)wrapper).GetAccessInfo();
3956             } catch (Exception e) {
3957                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3958                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3959             }
3960         return _ret_var;
3961         } else {
3962             return efl_ui_widget_access_info_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3963         }
3964     }
3965     private static efl_ui_widget_access_info_get_delegate efl_ui_widget_access_info_get_static_delegate;
3966
3967
3968      private delegate void efl_ui_widget_access_info_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String txt);
3969
3970
3971      public delegate void efl_ui_widget_access_info_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String txt);
3972      public static Efl.Eo.FunctionWrapper<efl_ui_widget_access_info_set_api_delegate> efl_ui_widget_access_info_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_access_info_set_api_delegate>(_Module, "efl_ui_widget_access_info_set");
3973      private static void access_info_set(System.IntPtr obj, System.IntPtr pd,  System.String txt)
3974     {
3975         Eina.Log.Debug("function efl_ui_widget_access_info_set was called");
3976         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3977         if(wrapper != null) {
3978
3979             try {
3980                 ((Widget)wrapper).SetAccessInfo( txt);
3981             } catch (Exception e) {
3982                 Eina.Log.Warning($"Callback error: {e.ToString()}");
3983                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3984             }
3985                                 } else {
3986             efl_ui_widget_access_info_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  txt);
3987         }
3988     }
3989     private static efl_ui_widget_access_info_set_delegate efl_ui_widget_access_info_set_static_delegate;
3990
3991
3992      private delegate Eina.Rect.NativeStruct efl_ui_widget_interest_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
3993
3994
3995      public delegate Eina.Rect.NativeStruct efl_ui_widget_interest_region_get_api_delegate(System.IntPtr obj);
3996      public static Efl.Eo.FunctionWrapper<efl_ui_widget_interest_region_get_api_delegate> efl_ui_widget_interest_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_interest_region_get_api_delegate>(_Module, "efl_ui_widget_interest_region_get");
3997      private static Eina.Rect.NativeStruct interest_region_get(System.IntPtr obj, System.IntPtr pd)
3998     {
3999         Eina.Log.Debug("function efl_ui_widget_interest_region_get was called");
4000         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4001         if(wrapper != null) {
4002                         Eina.Rect _ret_var = default(Eina.Rect);
4003             try {
4004                 _ret_var = ((Widget)wrapper).GetInterestRegion();
4005             } catch (Exception e) {
4006                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4007                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4008             }
4009         return _ret_var;
4010         } else {
4011             return efl_ui_widget_interest_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4012         }
4013     }
4014     private static efl_ui_widget_interest_region_get_delegate efl_ui_widget_interest_region_get_static_delegate;
4015
4016
4017      private delegate Eina.Rect.NativeStruct efl_ui_widget_focus_highlight_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
4018
4019
4020      public delegate Eina.Rect.NativeStruct efl_ui_widget_focus_highlight_geometry_get_api_delegate(System.IntPtr obj);
4021      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_highlight_geometry_get_api_delegate> efl_ui_widget_focus_highlight_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_highlight_geometry_get_api_delegate>(_Module, "efl_ui_widget_focus_highlight_geometry_get");
4022      private static Eina.Rect.NativeStruct focus_highlight_geometry_get(System.IntPtr obj, System.IntPtr pd)
4023     {
4024         Eina.Log.Debug("function efl_ui_widget_focus_highlight_geometry_get was called");
4025         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4026         if(wrapper != null) {
4027                         Eina.Rect _ret_var = default(Eina.Rect);
4028             try {
4029                 _ret_var = ((Widget)wrapper).GetFocusHighlightGeometry();
4030             } catch (Exception e) {
4031                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4032                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4033             }
4034         return _ret_var;
4035         } else {
4036             return efl_ui_widget_focus_highlight_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4037         }
4038     }
4039     private static efl_ui_widget_focus_highlight_geometry_get_delegate efl_ui_widget_focus_highlight_geometry_get_static_delegate;
4040
4041
4042      private delegate uint efl_ui_widget_focus_order_get_delegate(System.IntPtr obj, System.IntPtr pd);
4043
4044
4045      public delegate uint efl_ui_widget_focus_order_get_api_delegate(System.IntPtr obj);
4046      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_order_get_api_delegate> efl_ui_widget_focus_order_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_order_get_api_delegate>(_Module, "efl_ui_widget_focus_order_get");
4047      private static uint focus_order_get(System.IntPtr obj, System.IntPtr pd)
4048     {
4049         Eina.Log.Debug("function efl_ui_widget_focus_order_get was called");
4050         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4051         if(wrapper != null) {
4052                         uint _ret_var = default(uint);
4053             try {
4054                 _ret_var = ((Widget)wrapper).GetFocusOrder();
4055             } catch (Exception e) {
4056                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4057                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4058             }
4059         return _ret_var;
4060         } else {
4061             return efl_ui_widget_focus_order_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4062         }
4063     }
4064     private static efl_ui_widget_focus_order_get_delegate efl_ui_widget_focus_order_get_static_delegate;
4065
4066
4067      private delegate System.IntPtr efl_ui_widget_focus_custom_chain_get_delegate(System.IntPtr obj, System.IntPtr pd);
4068
4069
4070      public delegate System.IntPtr efl_ui_widget_focus_custom_chain_get_api_delegate(System.IntPtr obj);
4071      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_get_api_delegate> efl_ui_widget_focus_custom_chain_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_get_api_delegate>(_Module, "efl_ui_widget_focus_custom_chain_get");
4072      private static System.IntPtr focus_custom_chain_get(System.IntPtr obj, System.IntPtr pd)
4073     {
4074         Eina.Log.Debug("function efl_ui_widget_focus_custom_chain_get was called");
4075         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4076         if(wrapper != null) {
4077                         Eina.List<Efl.Canvas.Object> _ret_var = default(Eina.List<Efl.Canvas.Object>);
4078             try {
4079                 _ret_var = ((Widget)wrapper).GetFocusCustomChain();
4080             } catch (Exception e) {
4081                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4082                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4083             }
4084         return _ret_var.Handle;
4085         } else {
4086             return efl_ui_widget_focus_custom_chain_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4087         }
4088     }
4089     private static efl_ui_widget_focus_custom_chain_get_delegate efl_ui_widget_focus_custom_chain_get_static_delegate;
4090
4091
4092      private delegate void efl_ui_widget_focus_custom_chain_set_delegate(System.IntPtr obj, System.IntPtr pd,   System.IntPtr objs);
4093
4094
4095      public delegate void efl_ui_widget_focus_custom_chain_set_api_delegate(System.IntPtr obj,   System.IntPtr objs);
4096      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_set_api_delegate> efl_ui_widget_focus_custom_chain_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_set_api_delegate>(_Module, "efl_ui_widget_focus_custom_chain_set");
4097      private static void focus_custom_chain_set(System.IntPtr obj, System.IntPtr pd,  System.IntPtr objs)
4098     {
4099         Eina.Log.Debug("function efl_ui_widget_focus_custom_chain_set was called");
4100         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4101         if(wrapper != null) {
4102                     var _in_objs = new Eina.List<Efl.Canvas.Object>(objs, false, false);
4103
4104             try {
4105                 ((Widget)wrapper).SetFocusCustomChain( _in_objs);
4106             } catch (Exception e) {
4107                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4108                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4109             }
4110                                 } else {
4111             efl_ui_widget_focus_custom_chain_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  objs);
4112         }
4113     }
4114     private static efl_ui_widget_focus_custom_chain_set_delegate efl_ui_widget_focus_custom_chain_set_static_delegate;
4115
4116
4117     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Canvas.Object efl_ui_widget_focused_object_get_delegate(System.IntPtr obj, System.IntPtr pd);
4118
4119
4120     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Canvas.Object efl_ui_widget_focused_object_get_api_delegate(System.IntPtr obj);
4121      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focused_object_get_api_delegate> efl_ui_widget_focused_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focused_object_get_api_delegate>(_Module, "efl_ui_widget_focused_object_get");
4122      private static Efl.Canvas.Object focused_object_get(System.IntPtr obj, System.IntPtr pd)
4123     {
4124         Eina.Log.Debug("function efl_ui_widget_focused_object_get was called");
4125         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4126         if(wrapper != null) {
4127                         Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
4128             try {
4129                 _ret_var = ((Widget)wrapper).GetFocusedObject();
4130             } catch (Exception e) {
4131                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4132                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4133             }
4134         return _ret_var;
4135         } else {
4136             return efl_ui_widget_focused_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4137         }
4138     }
4139     private static efl_ui_widget_focused_object_get_delegate efl_ui_widget_focused_object_get_static_delegate;
4140
4141
4142      private delegate Efl.Ui.Focus.MovePolicy efl_ui_widget_focus_move_policy_get_delegate(System.IntPtr obj, System.IntPtr pd);
4143
4144
4145      public delegate Efl.Ui.Focus.MovePolicy efl_ui_widget_focus_move_policy_get_api_delegate(System.IntPtr obj);
4146      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_get_api_delegate> efl_ui_widget_focus_move_policy_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_get_api_delegate>(_Module, "efl_ui_widget_focus_move_policy_get");
4147      private static Efl.Ui.Focus.MovePolicy focus_move_policy_get(System.IntPtr obj, System.IntPtr pd)
4148     {
4149         Eina.Log.Debug("function efl_ui_widget_focus_move_policy_get was called");
4150         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4151         if(wrapper != null) {
4152                         Efl.Ui.Focus.MovePolicy _ret_var = default(Efl.Ui.Focus.MovePolicy);
4153             try {
4154                 _ret_var = ((Widget)wrapper).GetFocusMovePolicy();
4155             } catch (Exception e) {
4156                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4157                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4158             }
4159         return _ret_var;
4160         } else {
4161             return efl_ui_widget_focus_move_policy_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4162         }
4163     }
4164     private static efl_ui_widget_focus_move_policy_get_delegate efl_ui_widget_focus_move_policy_get_static_delegate;
4165
4166
4167      private delegate void efl_ui_widget_focus_move_policy_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.MovePolicy policy);
4168
4169
4170      public delegate void efl_ui_widget_focus_move_policy_set_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.MovePolicy policy);
4171      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_set_api_delegate> efl_ui_widget_focus_move_policy_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_set_api_delegate>(_Module, "efl_ui_widget_focus_move_policy_set");
4172      private static void focus_move_policy_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.MovePolicy policy)
4173     {
4174         Eina.Log.Debug("function efl_ui_widget_focus_move_policy_set was called");
4175         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4176         if(wrapper != null) {
4177
4178             try {
4179                 ((Widget)wrapper).SetFocusMovePolicy( policy);
4180             } catch (Exception e) {
4181                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4182                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4183             }
4184                                 } else {
4185             efl_ui_widget_focus_move_policy_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  policy);
4186         }
4187     }
4188     private static efl_ui_widget_focus_move_policy_set_delegate efl_ui_widget_focus_move_policy_set_static_delegate;
4189
4190
4191      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_move_policy_automatic_get_delegate(System.IntPtr obj, System.IntPtr pd);
4192
4193
4194      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_move_policy_automatic_get_api_delegate(System.IntPtr obj);
4195      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_automatic_get_api_delegate> efl_ui_widget_focus_move_policy_automatic_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_automatic_get_api_delegate>(_Module, "efl_ui_widget_focus_move_policy_automatic_get");
4196      private static bool focus_move_policy_automatic_get(System.IntPtr obj, System.IntPtr pd)
4197     {
4198         Eina.Log.Debug("function efl_ui_widget_focus_move_policy_automatic_get was called");
4199         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4200         if(wrapper != null) {
4201                         bool _ret_var = default(bool);
4202             try {
4203                 _ret_var = ((Widget)wrapper).GetFocusMovePolicyAutomatic();
4204             } catch (Exception e) {
4205                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4206                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4207             }
4208         return _ret_var;
4209         } else {
4210             return efl_ui_widget_focus_move_policy_automatic_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4211         }
4212     }
4213     private static efl_ui_widget_focus_move_policy_automatic_get_delegate efl_ui_widget_focus_move_policy_automatic_get_static_delegate;
4214
4215
4216      private delegate void efl_ui_widget_focus_move_policy_automatic_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool automatic);
4217
4218
4219      public delegate void efl_ui_widget_focus_move_policy_automatic_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool automatic);
4220      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_automatic_set_api_delegate> efl_ui_widget_focus_move_policy_automatic_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_move_policy_automatic_set_api_delegate>(_Module, "efl_ui_widget_focus_move_policy_automatic_set");
4221      private static void focus_move_policy_automatic_set(System.IntPtr obj, System.IntPtr pd,  bool automatic)
4222     {
4223         Eina.Log.Debug("function efl_ui_widget_focus_move_policy_automatic_set was called");
4224         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4225         if(wrapper != null) {
4226
4227             try {
4228                 ((Widget)wrapper).SetFocusMovePolicyAutomatic( automatic);
4229             } catch (Exception e) {
4230                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4231                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4232             }
4233                                 } else {
4234             efl_ui_widget_focus_move_policy_automatic_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  automatic);
4235         }
4236     }
4237     private static efl_ui_widget_focus_move_policy_automatic_set_delegate efl_ui_widget_focus_move_policy_automatic_set_static_delegate;
4238
4239
4240      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_input_event_handler_delegate(System.IntPtr obj, System.IntPtr pd,   ref Efl.Event.NativeStruct eo_event, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object source);
4241
4242
4243      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_input_event_handler_api_delegate(System.IntPtr obj,   ref Efl.Event.NativeStruct eo_event, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object source);
4244      public static Efl.Eo.FunctionWrapper<efl_ui_widget_input_event_handler_api_delegate> efl_ui_widget_input_event_handler_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_input_event_handler_api_delegate>(_Module, "efl_ui_widget_input_event_handler");
4245      private static bool widget_input_event_handler(System.IntPtr obj, System.IntPtr pd,  ref Efl.Event.NativeStruct eo_event,  Efl.Canvas.Object source)
4246     {
4247         Eina.Log.Debug("function efl_ui_widget_input_event_handler was called");
4248         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4249         if(wrapper != null) {
4250                     Efl.Event _in_eo_event = eo_event;
4251                                                     bool _ret_var = default(bool);
4252             try {
4253                 _ret_var = ((Widget)wrapper).WidgetInputEventHandler( ref _in_eo_event,  source);
4254             } catch (Exception e) {
4255                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4256                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4257             }
4258                         eo_event = _in_eo_event;
4259                 return _ret_var;
4260         } else {
4261             return efl_ui_widget_input_event_handler_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ref eo_event,  source);
4262         }
4263     }
4264     private static efl_ui_widget_input_event_handler_delegate efl_ui_widget_input_event_handler_static_delegate;
4265
4266
4267      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_on_access_activate_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Activate act);
4268
4269
4270      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_on_access_activate_api_delegate(System.IntPtr obj,   Efl.Ui.Activate act);
4271      public static Efl.Eo.FunctionWrapper<efl_ui_widget_on_access_activate_api_delegate> efl_ui_widget_on_access_activate_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_on_access_activate_api_delegate>(_Module, "efl_ui_widget_on_access_activate");
4272      private static bool on_access_activate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Activate act)
4273     {
4274         Eina.Log.Debug("function efl_ui_widget_on_access_activate was called");
4275         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4276         if(wrapper != null) {
4277                                                 bool _ret_var = default(bool);
4278             try {
4279                 _ret_var = ((Widget)wrapper).OnAccessActivate( act);
4280             } catch (Exception e) {
4281                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4282                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4283             }
4284                         return _ret_var;
4285         } else {
4286             return efl_ui_widget_on_access_activate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  act);
4287         }
4288     }
4289     private static efl_ui_widget_on_access_activate_delegate efl_ui_widget_on_access_activate_static_delegate;
4290
4291
4292      private delegate void efl_ui_widget_on_access_update_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool enable);
4293
4294
4295      public delegate void efl_ui_widget_on_access_update_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool enable);
4296      public static Efl.Eo.FunctionWrapper<efl_ui_widget_on_access_update_api_delegate> efl_ui_widget_on_access_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_on_access_update_api_delegate>(_Module, "efl_ui_widget_on_access_update");
4297      private static void on_access_update(System.IntPtr obj, System.IntPtr pd,  bool enable)
4298     {
4299         Eina.Log.Debug("function efl_ui_widget_on_access_update was called");
4300         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4301         if(wrapper != null) {
4302
4303             try {
4304                 ((Widget)wrapper).UpdateOnAccess( enable);
4305             } catch (Exception e) {
4306                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4307                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4308             }
4309                                 } else {
4310             efl_ui_widget_on_access_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  enable);
4311         }
4312     }
4313     private static efl_ui_widget_on_access_update_delegate efl_ui_widget_on_access_update_static_delegate;
4314
4315
4316      private delegate void efl_ui_widget_screen_reader_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool is_screen_reader);
4317
4318
4319      public delegate void efl_ui_widget_screen_reader_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool is_screen_reader);
4320      public static Efl.Eo.FunctionWrapper<efl_ui_widget_screen_reader_api_delegate> efl_ui_widget_screen_reader_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_screen_reader_api_delegate>(_Module, "efl_ui_widget_screen_reader");
4321      private static void screen_reader(System.IntPtr obj, System.IntPtr pd,  bool is_screen_reader)
4322     {
4323         Eina.Log.Debug("function efl_ui_widget_screen_reader was called");
4324         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4325         if(wrapper != null) {
4326
4327             try {
4328                 ((Widget)wrapper).ScreenReader( is_screen_reader);
4329             } catch (Exception e) {
4330                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4331                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4332             }
4333                                 } else {
4334             efl_ui_widget_screen_reader_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  is_screen_reader);
4335         }
4336     }
4337     private static efl_ui_widget_screen_reader_delegate efl_ui_widget_screen_reader_static_delegate;
4338
4339
4340      private delegate void efl_ui_widget_atspi_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool is_atspi);
4341
4342
4343      public delegate void efl_ui_widget_atspi_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool is_atspi);
4344      public static Efl.Eo.FunctionWrapper<efl_ui_widget_atspi_api_delegate> efl_ui_widget_atspi_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_atspi_api_delegate>(_Module, "efl_ui_widget_atspi");
4345      private static void atspi(System.IntPtr obj, System.IntPtr pd,  bool is_atspi)
4346     {
4347         Eina.Log.Debug("function efl_ui_widget_atspi was called");
4348         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4349         if(wrapper != null) {
4350
4351             try {
4352                 ((Widget)wrapper).Atspi( is_atspi);
4353             } catch (Exception e) {
4354                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4355                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4356             }
4357                                 } else {
4358             efl_ui_widget_atspi_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  is_atspi);
4359         }
4360     }
4361     private static efl_ui_widget_atspi_delegate efl_ui_widget_atspi_static_delegate;
4362
4363
4364      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_sub_object_add_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
4365
4366
4367      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_sub_object_add_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
4368      public static Efl.Eo.FunctionWrapper<efl_ui_widget_sub_object_add_api_delegate> efl_ui_widget_sub_object_add_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_sub_object_add_api_delegate>(_Module, "efl_ui_widget_sub_object_add");
4369      private static bool widget_sub_object_add(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sub_obj)
4370     {
4371         Eina.Log.Debug("function efl_ui_widget_sub_object_add was called");
4372         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4373         if(wrapper != null) {
4374                                                 bool _ret_var = default(bool);
4375             try {
4376                 _ret_var = ((Widget)wrapper).AddWidgetSubObject( sub_obj);
4377             } catch (Exception e) {
4378                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4379                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4380             }
4381                         return _ret_var;
4382         } else {
4383             return efl_ui_widget_sub_object_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sub_obj);
4384         }
4385     }
4386     private static efl_ui_widget_sub_object_add_delegate efl_ui_widget_sub_object_add_static_delegate;
4387
4388
4389      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_sub_object_del_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
4390
4391
4392      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_sub_object_del_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object sub_obj);
4393      public static Efl.Eo.FunctionWrapper<efl_ui_widget_sub_object_del_api_delegate> efl_ui_widget_sub_object_del_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_sub_object_del_api_delegate>(_Module, "efl_ui_widget_sub_object_del");
4394      private static bool widget_sub_object_del(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object sub_obj)
4395     {
4396         Eina.Log.Debug("function efl_ui_widget_sub_object_del was called");
4397         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4398         if(wrapper != null) {
4399                                                 bool _ret_var = default(bool);
4400             try {
4401                 _ret_var = ((Widget)wrapper).DelWidgetSubObject( sub_obj);
4402             } catch (Exception e) {
4403                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4404                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4405             }
4406                         return _ret_var;
4407         } else {
4408             return efl_ui_widget_sub_object_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sub_obj);
4409         }
4410     }
4411     private static efl_ui_widget_sub_object_del_delegate efl_ui_widget_sub_object_del_static_delegate;
4412
4413
4414      private delegate Eina.Error efl_ui_widget_theme_apply_delegate(System.IntPtr obj, System.IntPtr pd);
4415
4416
4417      public delegate Eina.Error efl_ui_widget_theme_apply_api_delegate(System.IntPtr obj);
4418      public static Efl.Eo.FunctionWrapper<efl_ui_widget_theme_apply_api_delegate> efl_ui_widget_theme_apply_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_theme_apply_api_delegate>(_Module, "efl_ui_widget_theme_apply");
4419      private static Eina.Error theme_apply(System.IntPtr obj, System.IntPtr pd)
4420     {
4421         Eina.Log.Debug("function efl_ui_widget_theme_apply was called");
4422         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4423         if(wrapper != null) {
4424                         Eina.Error _ret_var = default(Eina.Error);
4425             try {
4426                 _ret_var = ((Widget)wrapper).ThemeApply();
4427             } catch (Exception e) {
4428                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4429                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4430             }
4431         return _ret_var;
4432         } else {
4433             return efl_ui_widget_theme_apply_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4434         }
4435     }
4436     private static efl_ui_widget_theme_apply_delegate efl_ui_widget_theme_apply_static_delegate;
4437
4438
4439      private delegate void efl_ui_widget_scroll_hold_push_delegate(System.IntPtr obj, System.IntPtr pd);
4440
4441
4442      public delegate void efl_ui_widget_scroll_hold_push_api_delegate(System.IntPtr obj);
4443      public static Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_hold_push_api_delegate> efl_ui_widget_scroll_hold_push_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_hold_push_api_delegate>(_Module, "efl_ui_widget_scroll_hold_push");
4444      private static void scroll_hold_push(System.IntPtr obj, System.IntPtr pd)
4445     {
4446         Eina.Log.Debug("function efl_ui_widget_scroll_hold_push was called");
4447         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4448         if(wrapper != null) {
4449
4450             try {
4451                 ((Widget)wrapper).PushScrollHold();
4452             } catch (Exception e) {
4453                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4454                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4455             }
4456                 } else {
4457             efl_ui_widget_scroll_hold_push_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4458         }
4459     }
4460     private static efl_ui_widget_scroll_hold_push_delegate efl_ui_widget_scroll_hold_push_static_delegate;
4461
4462
4463      private delegate void efl_ui_widget_scroll_hold_pop_delegate(System.IntPtr obj, System.IntPtr pd);
4464
4465
4466      public delegate void efl_ui_widget_scroll_hold_pop_api_delegate(System.IntPtr obj);
4467      public static Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_hold_pop_api_delegate> efl_ui_widget_scroll_hold_pop_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_hold_pop_api_delegate>(_Module, "efl_ui_widget_scroll_hold_pop");
4468      private static void scroll_hold_pop(System.IntPtr obj, System.IntPtr pd)
4469     {
4470         Eina.Log.Debug("function efl_ui_widget_scroll_hold_pop was called");
4471         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4472         if(wrapper != null) {
4473
4474             try {
4475                 ((Widget)wrapper).PopScrollHold();
4476             } catch (Exception e) {
4477                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4478                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4479             }
4480                 } else {
4481             efl_ui_widget_scroll_hold_pop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4482         }
4483     }
4484     private static efl_ui_widget_scroll_hold_pop_delegate efl_ui_widget_scroll_hold_pop_static_delegate;
4485
4486
4487      private delegate void efl_ui_widget_scroll_freeze_push_delegate(System.IntPtr obj, System.IntPtr pd);
4488
4489
4490      public delegate void efl_ui_widget_scroll_freeze_push_api_delegate(System.IntPtr obj);
4491      public static Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_freeze_push_api_delegate> efl_ui_widget_scroll_freeze_push_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_freeze_push_api_delegate>(_Module, "efl_ui_widget_scroll_freeze_push");
4492      private static void scroll_freeze_push(System.IntPtr obj, System.IntPtr pd)
4493     {
4494         Eina.Log.Debug("function efl_ui_widget_scroll_freeze_push was called");
4495         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4496         if(wrapper != null) {
4497
4498             try {
4499                 ((Widget)wrapper).PushScrollFreeze();
4500             } catch (Exception e) {
4501                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4502                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4503             }
4504                 } else {
4505             efl_ui_widget_scroll_freeze_push_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4506         }
4507     }
4508     private static efl_ui_widget_scroll_freeze_push_delegate efl_ui_widget_scroll_freeze_push_static_delegate;
4509
4510
4511      private delegate void efl_ui_widget_scroll_freeze_pop_delegate(System.IntPtr obj, System.IntPtr pd);
4512
4513
4514      public delegate void efl_ui_widget_scroll_freeze_pop_api_delegate(System.IntPtr obj);
4515      public static Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_freeze_pop_api_delegate> efl_ui_widget_scroll_freeze_pop_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_scroll_freeze_pop_api_delegate>(_Module, "efl_ui_widget_scroll_freeze_pop");
4516      private static void scroll_freeze_pop(System.IntPtr obj, System.IntPtr pd)
4517     {
4518         Eina.Log.Debug("function efl_ui_widget_scroll_freeze_pop was called");
4519         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4520         if(wrapper != null) {
4521
4522             try {
4523                 ((Widget)wrapper).PopScrollFreeze();
4524             } catch (Exception e) {
4525                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4526                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4527             }
4528                 } else {
4529             efl_ui_widget_scroll_freeze_pop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4530         }
4531     }
4532     private static efl_ui_widget_scroll_freeze_pop_delegate efl_ui_widget_scroll_freeze_pop_static_delegate;
4533
4534
4535     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Canvas.Object efl_ui_widget_part_access_object_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String part);
4536
4537
4538     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Canvas.Object efl_ui_widget_part_access_object_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String part);
4539      public static Efl.Eo.FunctionWrapper<efl_ui_widget_part_access_object_get_api_delegate> efl_ui_widget_part_access_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_part_access_object_get_api_delegate>(_Module, "efl_ui_widget_part_access_object_get");
4540      private static Efl.Canvas.Object part_access_object_get(System.IntPtr obj, System.IntPtr pd,  System.String part)
4541     {
4542         Eina.Log.Debug("function efl_ui_widget_part_access_object_get was called");
4543         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4544         if(wrapper != null) {
4545                                                 Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
4546             try {
4547                 _ret_var = ((Widget)wrapper).GetPartAccessObject( part);
4548             } catch (Exception e) {
4549                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4550                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4551             }
4552                         return _ret_var;
4553         } else {
4554             return efl_ui_widget_part_access_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  part);
4555         }
4556     }
4557     private static efl_ui_widget_part_access_object_get_delegate efl_ui_widget_part_access_object_get_static_delegate;
4558
4559
4560     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Canvas.Object efl_ui_widget_newest_focus_order_get_delegate(System.IntPtr obj, System.IntPtr pd,   out uint newest_focus_order,  [MarshalAs(UnmanagedType.U1)]  bool can_focus_only);
4561
4562
4563     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Canvas.Object efl_ui_widget_newest_focus_order_get_api_delegate(System.IntPtr obj,   out uint newest_focus_order,  [MarshalAs(UnmanagedType.U1)]  bool can_focus_only);
4564      public static Efl.Eo.FunctionWrapper<efl_ui_widget_newest_focus_order_get_api_delegate> efl_ui_widget_newest_focus_order_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_newest_focus_order_get_api_delegate>(_Module, "efl_ui_widget_newest_focus_order_get");
4565      private static Efl.Canvas.Object newest_focus_order_get(System.IntPtr obj, System.IntPtr pd,  out uint newest_focus_order,  bool can_focus_only)
4566     {
4567         Eina.Log.Debug("function efl_ui_widget_newest_focus_order_get was called");
4568         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4569         if(wrapper != null) {
4570                                     newest_focus_order = default(uint);                                    Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
4571             try {
4572                 _ret_var = ((Widget)wrapper).GetNewestFocusOrder( out newest_focus_order,  can_focus_only);
4573             } catch (Exception e) {
4574                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4575                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4576             }
4577                                         return _ret_var;
4578         } else {
4579             return efl_ui_widget_newest_focus_order_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out newest_focus_order,  can_focus_only);
4580         }
4581     }
4582     private static efl_ui_widget_newest_focus_order_get_delegate efl_ui_widget_newest_focus_order_get_static_delegate;
4583
4584
4585      private delegate void efl_ui_widget_focus_next_object_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object next,   Efl.Ui.Focus.Direction dir);
4586
4587
4588      public delegate void efl_ui_widget_focus_next_object_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object next,   Efl.Ui.Focus.Direction dir);
4589      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_object_set_api_delegate> efl_ui_widget_focus_next_object_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_object_set_api_delegate>(_Module, "efl_ui_widget_focus_next_object_set");
4590      private static void focus_next_object_set(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object next,  Efl.Ui.Focus.Direction dir)
4591     {
4592         Eina.Log.Debug("function efl_ui_widget_focus_next_object_set was called");
4593         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4594         if(wrapper != null) {
4595
4596             try {
4597                 ((Widget)wrapper).SetFocusNextObject( next,  dir);
4598             } catch (Exception e) {
4599                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4600                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4601             }
4602                                                 } else {
4603             efl_ui_widget_focus_next_object_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  next,  dir);
4604         }
4605     }
4606     private static efl_ui_widget_focus_next_object_set_delegate efl_ui_widget_focus_next_object_set_static_delegate;
4607
4608
4609     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Canvas.Object efl_ui_widget_focus_next_object_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction dir);
4610
4611
4612     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Canvas.Object efl_ui_widget_focus_next_object_get_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction dir);
4613      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_object_get_api_delegate> efl_ui_widget_focus_next_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_object_get_api_delegate>(_Module, "efl_ui_widget_focus_next_object_get");
4614      private static Efl.Canvas.Object focus_next_object_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction dir)
4615     {
4616         Eina.Log.Debug("function efl_ui_widget_focus_next_object_get was called");
4617         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4618         if(wrapper != null) {
4619                                                 Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
4620             try {
4621                 _ret_var = ((Widget)wrapper).GetFocusNextObject( dir);
4622             } catch (Exception e) {
4623                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4624                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4625             }
4626                         return _ret_var;
4627         } else {
4628             return efl_ui_widget_focus_next_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
4629         }
4630     }
4631     private static efl_ui_widget_focus_next_object_get_delegate efl_ui_widget_focus_next_object_get_static_delegate;
4632
4633
4634      private delegate void efl_ui_widget_focus_next_item_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget next_item,   Efl.Ui.Focus.Direction dir);
4635
4636
4637      public delegate void efl_ui_widget_focus_next_item_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget next_item,   Efl.Ui.Focus.Direction dir);
4638      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_item_set_api_delegate> efl_ui_widget_focus_next_item_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_item_set_api_delegate>(_Module, "efl_ui_widget_focus_next_item_set");
4639      private static void focus_next_item_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Widget next_item,  Efl.Ui.Focus.Direction dir)
4640     {
4641         Eina.Log.Debug("function efl_ui_widget_focus_next_item_set was called");
4642         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4643         if(wrapper != null) {
4644
4645             try {
4646                 ((Widget)wrapper).SetFocusNextItem( next_item,  dir);
4647             } catch (Exception e) {
4648                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4649                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4650             }
4651                                                 } else {
4652             efl_ui_widget_focus_next_item_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  next_item,  dir);
4653         }
4654     }
4655     private static efl_ui_widget_focus_next_item_set_delegate efl_ui_widget_focus_next_item_set_static_delegate;
4656
4657
4658     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Widget efl_ui_widget_focus_next_item_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction dir);
4659
4660
4661     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Widget efl_ui_widget_focus_next_item_get_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction dir);
4662      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_item_get_api_delegate> efl_ui_widget_focus_next_item_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_item_get_api_delegate>(_Module, "efl_ui_widget_focus_next_item_get");
4663      private static Efl.Ui.Widget focus_next_item_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction dir)
4664     {
4665         Eina.Log.Debug("function efl_ui_widget_focus_next_item_get was called");
4666         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4667         if(wrapper != null) {
4668                                                 Efl.Ui.Widget _ret_var = default(Efl.Ui.Widget);
4669             try {
4670                 _ret_var = ((Widget)wrapper).GetFocusNextItem( dir);
4671             } catch (Exception e) {
4672                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4673                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4674             }
4675                         return _ret_var;
4676         } else {
4677             return efl_ui_widget_focus_next_item_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
4678         }
4679     }
4680     private static efl_ui_widget_focus_next_item_get_delegate efl_ui_widget_focus_next_item_get_static_delegate;
4681
4682
4683      private delegate void efl_ui_widget_focus_tree_unfocusable_handle_delegate(System.IntPtr obj, System.IntPtr pd);
4684
4685
4686      public delegate void efl_ui_widget_focus_tree_unfocusable_handle_api_delegate(System.IntPtr obj);
4687      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_tree_unfocusable_handle_api_delegate> efl_ui_widget_focus_tree_unfocusable_handle_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_tree_unfocusable_handle_api_delegate>(_Module, "efl_ui_widget_focus_tree_unfocusable_handle");
4688      private static void focus_tree_unfocusable_handle(System.IntPtr obj, System.IntPtr pd)
4689     {
4690         Eina.Log.Debug("function efl_ui_widget_focus_tree_unfocusable_handle was called");
4691         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4692         if(wrapper != null) {
4693
4694             try {
4695                 ((Widget)wrapper).FocusTreeUnfocusableHandle();
4696             } catch (Exception e) {
4697                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4698                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4699             }
4700                 } else {
4701             efl_ui_widget_focus_tree_unfocusable_handle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4702         }
4703     }
4704     private static efl_ui_widget_focus_tree_unfocusable_handle_delegate efl_ui_widget_focus_tree_unfocusable_handle_static_delegate;
4705
4706
4707      private delegate void efl_ui_widget_focus_custom_chain_prepend_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object relative_child);
4708
4709
4710      public delegate void efl_ui_widget_focus_custom_chain_prepend_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object relative_child);
4711      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_prepend_api_delegate> efl_ui_widget_focus_custom_chain_prepend_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_prepend_api_delegate>(_Module, "efl_ui_widget_focus_custom_chain_prepend");
4712      private static void focus_custom_chain_prepend(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object child,  Efl.Canvas.Object relative_child)
4713     {
4714         Eina.Log.Debug("function efl_ui_widget_focus_custom_chain_prepend was called");
4715         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4716         if(wrapper != null) {
4717
4718             try {
4719                 ((Widget)wrapper).FocusCustomChainPrepend( child,  relative_child);
4720             } catch (Exception e) {
4721                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4722                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4723             }
4724                                                 } else {
4725             efl_ui_widget_focus_custom_chain_prepend_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  relative_child);
4726         }
4727     }
4728     private static efl_ui_widget_focus_custom_chain_prepend_delegate efl_ui_widget_focus_custom_chain_prepend_static_delegate;
4729
4730
4731      private delegate void efl_ui_widget_focus_cycle_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction dir);
4732
4733
4734      public delegate void efl_ui_widget_focus_cycle_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction dir);
4735      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_cycle_api_delegate> efl_ui_widget_focus_cycle_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_cycle_api_delegate>(_Module, "efl_ui_widget_focus_cycle");
4736      private static void focus_cycle(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction dir)
4737     {
4738         Eina.Log.Debug("function efl_ui_widget_focus_cycle was called");
4739         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4740         if(wrapper != null) {
4741
4742             try {
4743                 ((Widget)wrapper).FocusCycle( dir);
4744             } catch (Exception e) {
4745                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4746                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4747             }
4748                                 } else {
4749             efl_ui_widget_focus_cycle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
4750         }
4751     }
4752     private static efl_ui_widget_focus_cycle_delegate efl_ui_widget_focus_cycle_static_delegate;
4753
4754
4755      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_direction_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
4756
4757
4758      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_direction_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
4759      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_api_delegate> efl_ui_widget_focus_direction_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_api_delegate>(_Module, "efl_ui_widget_focus_direction");
4760      private static bool focus_direction(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object kw_base,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight)
4761     {
4762         Eina.Log.Debug("function efl_ui_widget_focus_direction was called");
4763         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4764         if(wrapper != null) {
4765                                                                             direction = default(Efl.Canvas.Object);        direction_item = default(Efl.Ui.Widget);        weight = default(double);                                                    bool _ret_var = default(bool);
4766             try {
4767                 _ret_var = ((Widget)wrapper).FocusDirection( kw_base,  degree,  out direction,  out direction_item,  out weight);
4768             } catch (Exception e) {
4769                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4770                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4771             }
4772                                                                                         return _ret_var;
4773         } else {
4774             return efl_ui_widget_focus_direction_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  kw_base,  degree,  out direction,  out direction_item,  out weight);
4775         }
4776     }
4777     private static efl_ui_widget_focus_direction_delegate efl_ui_widget_focus_direction_static_delegate;
4778
4779
4780      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_next_manager_is_delegate(System.IntPtr obj, System.IntPtr pd);
4781
4782
4783      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_next_manager_is_api_delegate(System.IntPtr obj);
4784      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_manager_is_api_delegate> efl_ui_widget_focus_next_manager_is_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_manager_is_api_delegate>(_Module, "efl_ui_widget_focus_next_manager_is");
4785      private static bool focus_next_manager_is(System.IntPtr obj, System.IntPtr pd)
4786     {
4787         Eina.Log.Debug("function efl_ui_widget_focus_next_manager_is was called");
4788         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4789         if(wrapper != null) {
4790                         bool _ret_var = default(bool);
4791             try {
4792                 _ret_var = ((Widget)wrapper).IsFocusNextManager();
4793             } catch (Exception e) {
4794                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4795                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4796             }
4797         return _ret_var;
4798         } else {
4799             return efl_ui_widget_focus_next_manager_is_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4800         }
4801     }
4802     private static efl_ui_widget_focus_next_manager_is_delegate efl_ui_widget_focus_next_manager_is_static_delegate;
4803
4804
4805      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_list_direction_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   System.IntPtr items,   System.IntPtr list_data_get,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
4806
4807
4808      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_list_direction_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   System.IntPtr items,   System.IntPtr list_data_get,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
4809      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_list_direction_get_api_delegate> efl_ui_widget_focus_list_direction_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_list_direction_get_api_delegate>(_Module, "efl_ui_widget_focus_list_direction_get");
4810      private static bool focus_list_direction_get(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object kw_base,  System.IntPtr items,  System.IntPtr list_data_get,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight)
4811     {
4812         Eina.Log.Debug("function efl_ui_widget_focus_list_direction_get was called");
4813         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4814         if(wrapper != null) {
4815                             var _in_items = new Eina.List<Efl.Object>(items, false, false);
4816                                                                                 direction = default(Efl.Canvas.Object);        direction_item = default(Efl.Ui.Widget);        weight = default(double);                                                                    bool _ret_var = default(bool);
4817             try {
4818                 _ret_var = ((Widget)wrapper).GetFocusListDirection( kw_base,  _in_items,  list_data_get,  degree,  out direction,  out direction_item,  out weight);
4819             } catch (Exception e) {
4820                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4821                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4822             }
4823                                                                                                                         return _ret_var;
4824         } else {
4825             return efl_ui_widget_focus_list_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  kw_base,  items,  list_data_get,  degree,  out direction,  out direction_item,  out weight);
4826         }
4827     }
4828     private static efl_ui_widget_focus_list_direction_get_delegate efl_ui_widget_focus_list_direction_get_static_delegate;
4829
4830
4831      private delegate void efl_ui_widget_focused_object_clear_delegate(System.IntPtr obj, System.IntPtr pd);
4832
4833
4834      public delegate void efl_ui_widget_focused_object_clear_api_delegate(System.IntPtr obj);
4835      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focused_object_clear_api_delegate> efl_ui_widget_focused_object_clear_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focused_object_clear_api_delegate>(_Module, "efl_ui_widget_focused_object_clear");
4836      private static void focused_object_clear(System.IntPtr obj, System.IntPtr pd)
4837     {
4838         Eina.Log.Debug("function efl_ui_widget_focused_object_clear was called");
4839         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4840         if(wrapper != null) {
4841
4842             try {
4843                 ((Widget)wrapper).ClearFocusedObject();
4844             } catch (Exception e) {
4845                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4846                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4847             }
4848                 } else {
4849             efl_ui_widget_focused_object_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4850         }
4851     }
4852     private static efl_ui_widget_focused_object_clear_delegate efl_ui_widget_focused_object_clear_static_delegate;
4853
4854
4855      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_direction_go_delegate(System.IntPtr obj, System.IntPtr pd,   double degree);
4856
4857
4858      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_direction_go_api_delegate(System.IntPtr obj,   double degree);
4859      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_go_api_delegate> efl_ui_widget_focus_direction_go_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_go_api_delegate>(_Module, "efl_ui_widget_focus_direction_go");
4860      private static bool focus_direction_go(System.IntPtr obj, System.IntPtr pd,  double degree)
4861     {
4862         Eina.Log.Debug("function efl_ui_widget_focus_direction_go was called");
4863         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4864         if(wrapper != null) {
4865                                                 bool _ret_var = default(bool);
4866             try {
4867                 _ret_var = ((Widget)wrapper).FocusDirectionGo( degree);
4868             } catch (Exception e) {
4869                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4870                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4871             }
4872                         return _ret_var;
4873         } else {
4874             return efl_ui_widget_focus_direction_go_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  degree);
4875         }
4876     }
4877     private static efl_ui_widget_focus_direction_go_delegate efl_ui_widget_focus_direction_go_static_delegate;
4878
4879
4880      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_next_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
4881
4882
4883      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_next_get_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
4884      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_get_api_delegate> efl_ui_widget_focus_next_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_get_api_delegate>(_Module, "efl_ui_widget_focus_next_get");
4885      private static bool focus_next_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item)
4886     {
4887         Eina.Log.Debug("function efl_ui_widget_focus_next_get was called");
4888         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4889         if(wrapper != null) {
4890                                                     next = default(Efl.Canvas.Object);        next_item = default(Efl.Ui.Widget);                                    bool _ret_var = default(bool);
4891             try {
4892                 _ret_var = ((Widget)wrapper).GetFocusNext( dir,  out next,  out next_item);
4893             } catch (Exception e) {
4894                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4895                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4896             }
4897                                                         return _ret_var;
4898         } else {
4899             return efl_ui_widget_focus_next_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir,  out next,  out next_item);
4900         }
4901     }
4902     private static efl_ui_widget_focus_next_get_delegate efl_ui_widget_focus_next_get_static_delegate;
4903
4904
4905      private delegate void efl_ui_widget_focus_restore_delegate(System.IntPtr obj, System.IntPtr pd);
4906
4907
4908      public delegate void efl_ui_widget_focus_restore_api_delegate(System.IntPtr obj);
4909      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_restore_api_delegate> efl_ui_widget_focus_restore_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_restore_api_delegate>(_Module, "efl_ui_widget_focus_restore");
4910      private static void focus_restore(System.IntPtr obj, System.IntPtr pd)
4911     {
4912         Eina.Log.Debug("function efl_ui_widget_focus_restore was called");
4913         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4914         if(wrapper != null) {
4915
4916             try {
4917                 ((Widget)wrapper).FocusRestore();
4918             } catch (Exception e) {
4919                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4920                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4921             }
4922                 } else {
4923             efl_ui_widget_focus_restore_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4924         }
4925     }
4926     private static efl_ui_widget_focus_restore_delegate efl_ui_widget_focus_restore_static_delegate;
4927
4928
4929      private delegate void efl_ui_widget_focus_custom_chain_unset_delegate(System.IntPtr obj, System.IntPtr pd);
4930
4931
4932      public delegate void efl_ui_widget_focus_custom_chain_unset_api_delegate(System.IntPtr obj);
4933      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_unset_api_delegate> efl_ui_widget_focus_custom_chain_unset_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_unset_api_delegate>(_Module, "efl_ui_widget_focus_custom_chain_unset");
4934      private static void focus_custom_chain_unset(System.IntPtr obj, System.IntPtr pd)
4935     {
4936         Eina.Log.Debug("function efl_ui_widget_focus_custom_chain_unset was called");
4937         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4938         if(wrapper != null) {
4939
4940             try {
4941                 ((Widget)wrapper).UnsetFocusCustomChain();
4942             } catch (Exception e) {
4943                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4944                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4945             }
4946                 } else {
4947             efl_ui_widget_focus_custom_chain_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4948         }
4949     }
4950     private static efl_ui_widget_focus_custom_chain_unset_delegate efl_ui_widget_focus_custom_chain_unset_static_delegate;
4951
4952
4953      private delegate void efl_ui_widget_focus_steal_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget item);
4954
4955
4956      public delegate void efl_ui_widget_focus_steal_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget item);
4957      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_steal_api_delegate> efl_ui_widget_focus_steal_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_steal_api_delegate>(_Module, "efl_ui_widget_focus_steal");
4958      private static void focus_steal(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Widget item)
4959     {
4960         Eina.Log.Debug("function efl_ui_widget_focus_steal was called");
4961         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4962         if(wrapper != null) {
4963
4964             try {
4965                 ((Widget)wrapper).FocusSteal( item);
4966             } catch (Exception e) {
4967                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4968                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4969             }
4970                                 } else {
4971             efl_ui_widget_focus_steal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  item);
4972         }
4973     }
4974     private static efl_ui_widget_focus_steal_delegate efl_ui_widget_focus_steal_static_delegate;
4975
4976
4977      private delegate void efl_ui_widget_focus_hide_handle_delegate(System.IntPtr obj, System.IntPtr pd);
4978
4979
4980      public delegate void efl_ui_widget_focus_hide_handle_api_delegate(System.IntPtr obj);
4981      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_hide_handle_api_delegate> efl_ui_widget_focus_hide_handle_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_hide_handle_api_delegate>(_Module, "efl_ui_widget_focus_hide_handle");
4982      private static void focus_hide_handle(System.IntPtr obj, System.IntPtr pd)
4983     {
4984         Eina.Log.Debug("function efl_ui_widget_focus_hide_handle was called");
4985         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4986         if(wrapper != null) {
4987
4988             try {
4989                 ((Widget)wrapper).FocusHideHandle();
4990             } catch (Exception e) {
4991                 Eina.Log.Warning($"Callback error: {e.ToString()}");
4992                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4993             }
4994                 } else {
4995             efl_ui_widget_focus_hide_handle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4996         }
4997     }
4998     private static efl_ui_widget_focus_hide_handle_delegate efl_ui_widget_focus_hide_handle_static_delegate;
4999
5000
5001      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_next_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
5002
5003
5004      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_next_api_delegate(System.IntPtr obj,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
5005      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_api_delegate> efl_ui_widget_focus_next_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_next_api_delegate>(_Module, "efl_ui_widget_focus_next");
5006      private static bool focus_next(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item)
5007     {
5008         Eina.Log.Debug("function efl_ui_widget_focus_next was called");
5009         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5010         if(wrapper != null) {
5011                                                     next = default(Efl.Canvas.Object);        next_item = default(Efl.Ui.Widget);                                    bool _ret_var = default(bool);
5012             try {
5013                 _ret_var = ((Widget)wrapper).FocusNext( dir,  out next,  out next_item);
5014             } catch (Exception e) {
5015                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5016                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5017             }
5018                                                         return _ret_var;
5019         } else {
5020             return efl_ui_widget_focus_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir,  out next,  out next_item);
5021         }
5022     }
5023     private static efl_ui_widget_focus_next_delegate efl_ui_widget_focus_next_static_delegate;
5024
5025
5026      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_list_next_get_delegate(System.IntPtr obj, System.IntPtr pd,   System.IntPtr items,   System.IntPtr list_data_get,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
5027
5028
5029      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_list_next_get_api_delegate(System.IntPtr obj,   System.IntPtr items,   System.IntPtr list_data_get,   Efl.Ui.Focus.Direction dir, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object next, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget next_item);
5030      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_list_next_get_api_delegate> efl_ui_widget_focus_list_next_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_list_next_get_api_delegate>(_Module, "efl_ui_widget_focus_list_next_get");
5031      private static bool focus_list_next_get(System.IntPtr obj, System.IntPtr pd,  System.IntPtr items,  System.IntPtr list_data_get,  Efl.Ui.Focus.Direction dir,  out Efl.Canvas.Object next,  out Efl.Ui.Widget next_item)
5032     {
5033         Eina.Log.Debug("function efl_ui_widget_focus_list_next_get was called");
5034         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5035         if(wrapper != null) {
5036                     var _in_items = new Eina.List<Efl.Object>(items, false, false);
5037                                                                 next = default(Efl.Canvas.Object);        next_item = default(Efl.Ui.Widget);                                                    bool _ret_var = default(bool);
5038             try {
5039                 _ret_var = ((Widget)wrapper).GetFocusListNext( _in_items,  list_data_get,  dir,  out next,  out next_item);
5040             } catch (Exception e) {
5041                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5042                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5043             }
5044                                                                                         return _ret_var;
5045         } else {
5046             return efl_ui_widget_focus_list_next_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  items,  list_data_get,  dir,  out next,  out next_item);
5047         }
5048     }
5049     private static efl_ui_widget_focus_list_next_get_delegate efl_ui_widget_focus_list_next_get_static_delegate;
5050
5051
5052      private delegate void efl_ui_widget_focus_mouse_up_handle_delegate(System.IntPtr obj, System.IntPtr pd);
5053
5054
5055      public delegate void efl_ui_widget_focus_mouse_up_handle_api_delegate(System.IntPtr obj);
5056      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_mouse_up_handle_api_delegate> efl_ui_widget_focus_mouse_up_handle_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_mouse_up_handle_api_delegate>(_Module, "efl_ui_widget_focus_mouse_up_handle");
5057      private static void focus_mouse_up_handle(System.IntPtr obj, System.IntPtr pd)
5058     {
5059         Eina.Log.Debug("function efl_ui_widget_focus_mouse_up_handle was called");
5060         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5061         if(wrapper != null) {
5062
5063             try {
5064                 ((Widget)wrapper).FocusMouseUpHandle();
5065             } catch (Exception e) {
5066                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5067                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5068             }
5069                 } else {
5070             efl_ui_widget_focus_mouse_up_handle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5071         }
5072     }
5073     private static efl_ui_widget_focus_mouse_up_handle_delegate efl_ui_widget_focus_mouse_up_handle_static_delegate;
5074
5075
5076      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_direction_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
5077
5078
5079      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_direction_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object kw_base,   double degree, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  out Efl.Canvas.Object direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  out Efl.Ui.Widget direction_item,   out double weight);
5080      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_get_api_delegate> efl_ui_widget_focus_direction_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_get_api_delegate>(_Module, "efl_ui_widget_focus_direction_get");
5081      private static bool focus_direction_get(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object kw_base,  double degree,  out Efl.Canvas.Object direction,  out Efl.Ui.Widget direction_item,  out double weight)
5082     {
5083         Eina.Log.Debug("function efl_ui_widget_focus_direction_get was called");
5084         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5085         if(wrapper != null) {
5086                                                                             direction = default(Efl.Canvas.Object);        direction_item = default(Efl.Ui.Widget);        weight = default(double);                                                    bool _ret_var = default(bool);
5087             try {
5088                 _ret_var = ((Widget)wrapper).GetFocusDirection( kw_base,  degree,  out direction,  out direction_item,  out weight);
5089             } catch (Exception e) {
5090                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5091                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5092             }
5093                                                                                         return _ret_var;
5094         } else {
5095             return efl_ui_widget_focus_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  kw_base,  degree,  out direction,  out direction_item,  out weight);
5096         }
5097     }
5098     private static efl_ui_widget_focus_direction_get_delegate efl_ui_widget_focus_direction_get_static_delegate;
5099
5100
5101      private delegate void efl_ui_widget_focus_disabled_handle_delegate(System.IntPtr obj, System.IntPtr pd);
5102
5103
5104      public delegate void efl_ui_widget_focus_disabled_handle_api_delegate(System.IntPtr obj);
5105      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_disabled_handle_api_delegate> efl_ui_widget_focus_disabled_handle_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_disabled_handle_api_delegate>(_Module, "efl_ui_widget_focus_disabled_handle");
5106      private static void focus_disabled_handle(System.IntPtr obj, System.IntPtr pd)
5107     {
5108         Eina.Log.Debug("function efl_ui_widget_focus_disabled_handle was called");
5109         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5110         if(wrapper != null) {
5111
5112             try {
5113                 ((Widget)wrapper).FocusDisabledHandle();
5114             } catch (Exception e) {
5115                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5116                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5117             }
5118                 } else {
5119             efl_ui_widget_focus_disabled_handle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5120         }
5121     }
5122     private static efl_ui_widget_focus_disabled_handle_delegate efl_ui_widget_focus_disabled_handle_static_delegate;
5123
5124
5125      private delegate void efl_ui_widget_focus_custom_chain_append_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object relative_child);
5126
5127
5128      public delegate void efl_ui_widget_focus_custom_chain_append_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object child, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Canvas.Object, Efl.Eo.NonOwnTag>))]  Efl.Canvas.Object relative_child);
5129      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_append_api_delegate> efl_ui_widget_focus_custom_chain_append_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_custom_chain_append_api_delegate>(_Module, "efl_ui_widget_focus_custom_chain_append");
5130      private static void focus_custom_chain_append(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Object child,  Efl.Canvas.Object relative_child)
5131     {
5132         Eina.Log.Debug("function efl_ui_widget_focus_custom_chain_append was called");
5133         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5134         if(wrapper != null) {
5135
5136             try {
5137                 ((Widget)wrapper).AppendFocusCustomChain( child,  relative_child);
5138             } catch (Exception e) {
5139                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5140                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5141             }
5142                                                 } else {
5143             efl_ui_widget_focus_custom_chain_append_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child,  relative_child);
5144         }
5145     }
5146     private static efl_ui_widget_focus_custom_chain_append_delegate efl_ui_widget_focus_custom_chain_append_static_delegate;
5147
5148
5149      private delegate void efl_ui_widget_focus_reconfigure_delegate(System.IntPtr obj, System.IntPtr pd);
5150
5151
5152      public delegate void efl_ui_widget_focus_reconfigure_api_delegate(System.IntPtr obj);
5153      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_reconfigure_api_delegate> efl_ui_widget_focus_reconfigure_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_reconfigure_api_delegate>(_Module, "efl_ui_widget_focus_reconfigure");
5154      private static void focus_reconfigure(System.IntPtr obj, System.IntPtr pd)
5155     {
5156         Eina.Log.Debug("function efl_ui_widget_focus_reconfigure was called");
5157         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5158         if(wrapper != null) {
5159
5160             try {
5161                 ((Widget)wrapper).FocusReconfigure();
5162             } catch (Exception e) {
5163                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5164                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5165             }
5166                 } else {
5167             efl_ui_widget_focus_reconfigure_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5168         }
5169     }
5170     private static efl_ui_widget_focus_reconfigure_delegate efl_ui_widget_focus_reconfigure_static_delegate;
5171
5172
5173      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_direction_manager_is_delegate(System.IntPtr obj, System.IntPtr pd);
5174
5175
5176      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_direction_manager_is_api_delegate(System.IntPtr obj);
5177      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_manager_is_api_delegate> efl_ui_widget_focus_direction_manager_is_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_direction_manager_is_api_delegate>(_Module, "efl_ui_widget_focus_direction_manager_is");
5178      private static bool focus_direction_manager_is(System.IntPtr obj, System.IntPtr pd)
5179     {
5180         Eina.Log.Debug("function efl_ui_widget_focus_direction_manager_is was called");
5181         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5182         if(wrapper != null) {
5183                         bool _ret_var = default(bool);
5184             try {
5185                 _ret_var = ((Widget)wrapper).IsFocusDirectionManager();
5186             } catch (Exception e) {
5187                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5188                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5189             }
5190         return _ret_var;
5191         } else {
5192             return efl_ui_widget_focus_direction_manager_is_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5193         }
5194     }
5195     private static efl_ui_widget_focus_direction_manager_is_delegate efl_ui_widget_focus_direction_manager_is_static_delegate;
5196
5197
5198      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_widget_focus_state_apply_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.WidgetFocusState.NativeStruct current_state,   ref Efl.Ui.WidgetFocusState.NativeStruct configured_state, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget redirect);
5199
5200
5201      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_widget_focus_state_apply_api_delegate(System.IntPtr obj,   Efl.Ui.WidgetFocusState.NativeStruct current_state,   ref Efl.Ui.WidgetFocusState.NativeStruct configured_state, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Widget, Efl.Eo.NonOwnTag>))]  Efl.Ui.Widget redirect);
5202      public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_state_apply_api_delegate> efl_ui_widget_focus_state_apply_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_state_apply_api_delegate>(_Module, "efl_ui_widget_focus_state_apply");
5203      private static bool focus_state_apply(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.WidgetFocusState.NativeStruct current_state,  ref Efl.Ui.WidgetFocusState.NativeStruct configured_state,  Efl.Ui.Widget redirect)
5204     {
5205         Eina.Log.Debug("function efl_ui_widget_focus_state_apply was called");
5206         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5207         if(wrapper != null) {
5208                     Efl.Ui.WidgetFocusState _in_current_state = current_state;
5209                                 Efl.Ui.WidgetFocusState _out_configured_state = default(Efl.Ui.WidgetFocusState);
5210                                             bool _ret_var = default(bool);
5211             try {
5212                 _ret_var = ((Widget)wrapper).FocusStateApply( _in_current_state,  ref _out_configured_state,  redirect);
5213             } catch (Exception e) {
5214                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5215                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5216             }
5217                 configured_state = _out_configured_state;
5218                                         return _ret_var;
5219         } else {
5220             return efl_ui_widget_focus_state_apply_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  current_state,  ref configured_state,  redirect);
5221         }
5222     }
5223     private static efl_ui_widget_focus_state_apply_delegate efl_ui_widget_focus_state_apply_static_delegate;
5224
5225
5226     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_part_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String name);
5227
5228
5229     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_part_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String name);
5230      public static Efl.Eo.FunctionWrapper<efl_part_get_api_delegate> efl_part_get_ptr = new Efl.Eo.FunctionWrapper<efl_part_get_api_delegate>(_Module, "efl_part_get");
5231      private static Efl.Object part_get(System.IntPtr obj, System.IntPtr pd,  System.String name)
5232     {
5233         Eina.Log.Debug("function efl_part_get was called");
5234         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5235         if(wrapper != null) {
5236                                                 Efl.Object _ret_var = default(Efl.Object);
5237             try {
5238                 _ret_var = ((Widget)wrapper).GetPart( name);
5239             } catch (Exception e) {
5240                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5241                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5242             }
5243                         return _ret_var;
5244         } else {
5245             return efl_part_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name);
5246         }
5247     }
5248     private static efl_part_get_delegate efl_part_get_static_delegate;
5249
5250
5251      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_action_name_get_delegate(System.IntPtr obj, System.IntPtr pd,   int id);
5252
5253
5254      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_action_name_get_api_delegate(System.IntPtr obj,   int id);
5255      public static Efl.Eo.FunctionWrapper<efl_access_action_name_get_api_delegate> efl_access_action_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_action_name_get_api_delegate>(_Module, "efl_access_action_name_get");
5256      private static System.String action_name_get(System.IntPtr obj, System.IntPtr pd,  int id)
5257     {
5258         Eina.Log.Debug("function efl_access_action_name_get was called");
5259         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5260         if(wrapper != null) {
5261                                                 System.String _ret_var = default(System.String);
5262             try {
5263                 _ret_var = ((Widget)wrapper).GetActionName( id);
5264             } catch (Exception e) {
5265                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5266                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5267             }
5268                         return _ret_var;
5269         } else {
5270             return efl_access_action_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id);
5271         }
5272     }
5273     private static efl_access_action_name_get_delegate efl_access_action_name_get_static_delegate;
5274
5275
5276      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_action_localized_name_get_delegate(System.IntPtr obj, System.IntPtr pd,   int id);
5277
5278
5279      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_action_localized_name_get_api_delegate(System.IntPtr obj,   int id);
5280      public static Efl.Eo.FunctionWrapper<efl_access_action_localized_name_get_api_delegate> efl_access_action_localized_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_action_localized_name_get_api_delegate>(_Module, "efl_access_action_localized_name_get");
5281      private static System.String action_localized_name_get(System.IntPtr obj, System.IntPtr pd,  int id)
5282     {
5283         Eina.Log.Debug("function efl_access_action_localized_name_get was called");
5284         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5285         if(wrapper != null) {
5286                                                 System.String _ret_var = default(System.String);
5287             try {
5288                 _ret_var = ((Widget)wrapper).GetActionLocalizedName( id);
5289             } catch (Exception e) {
5290                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5291                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5292             }
5293                         return _ret_var;
5294         } else {
5295             return efl_access_action_localized_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id);
5296         }
5297     }
5298     private static efl_access_action_localized_name_get_delegate efl_access_action_localized_name_get_static_delegate;
5299
5300
5301      private delegate System.IntPtr efl_access_action_actions_get_delegate(System.IntPtr obj, System.IntPtr pd);
5302
5303
5304      public delegate System.IntPtr efl_access_action_actions_get_api_delegate(System.IntPtr obj);
5305      public static Efl.Eo.FunctionWrapper<efl_access_action_actions_get_api_delegate> efl_access_action_actions_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_action_actions_get_api_delegate>(_Module, "efl_access_action_actions_get");
5306      private static System.IntPtr actions_get(System.IntPtr obj, System.IntPtr pd)
5307     {
5308         Eina.Log.Debug("function efl_access_action_actions_get was called");
5309         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5310         if(wrapper != null) {
5311                         Eina.List<Efl.Access.ActionData> _ret_var = default(Eina.List<Efl.Access.ActionData>);
5312             try {
5313                 _ret_var = ((Widget)wrapper).GetActions();
5314             } catch (Exception e) {
5315                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5316                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5317             }
5318         return _ret_var.Handle;
5319         } else {
5320             return efl_access_action_actions_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5321         }
5322     }
5323     private static efl_access_action_actions_get_delegate efl_access_action_actions_get_static_delegate;
5324
5325
5326      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_action_do_delegate(System.IntPtr obj, System.IntPtr pd,   int id);
5327
5328
5329      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_action_do_api_delegate(System.IntPtr obj,   int id);
5330      public static Efl.Eo.FunctionWrapper<efl_access_action_do_api_delegate> efl_access_action_do_ptr = new Efl.Eo.FunctionWrapper<efl_access_action_do_api_delegate>(_Module, "efl_access_action_do");
5331      private static bool action_do(System.IntPtr obj, System.IntPtr pd,  int id)
5332     {
5333         Eina.Log.Debug("function efl_access_action_do was called");
5334         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5335         if(wrapper != null) {
5336                                                 bool _ret_var = default(bool);
5337             try {
5338                 _ret_var = ((Widget)wrapper).ActionDo( id);
5339             } catch (Exception e) {
5340                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5341                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5342             }
5343                         return _ret_var;
5344         } else {
5345             return efl_access_action_do_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id);
5346         }
5347     }
5348     private static efl_access_action_do_delegate efl_access_action_do_static_delegate;
5349
5350
5351      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] private delegate System.String efl_access_action_keybinding_get_delegate(System.IntPtr obj, System.IntPtr pd,   int id);
5352
5353
5354      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] public delegate System.String efl_access_action_keybinding_get_api_delegate(System.IntPtr obj,   int id);
5355      public static Efl.Eo.FunctionWrapper<efl_access_action_keybinding_get_api_delegate> efl_access_action_keybinding_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_action_keybinding_get_api_delegate>(_Module, "efl_access_action_keybinding_get");
5356      private static System.String action_keybinding_get(System.IntPtr obj, System.IntPtr pd,  int id)
5357     {
5358         Eina.Log.Debug("function efl_access_action_keybinding_get was called");
5359         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5360         if(wrapper != null) {
5361                                                 System.String _ret_var = default(System.String);
5362             try {
5363                 _ret_var = ((Widget)wrapper).GetActionKeybinding( id);
5364             } catch (Exception e) {
5365                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5366                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5367             }
5368                         return _ret_var;
5369         } else {
5370             return efl_access_action_keybinding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id);
5371         }
5372     }
5373     private static efl_access_action_keybinding_get_delegate efl_access_action_keybinding_get_static_delegate;
5374
5375
5376      private delegate int efl_access_component_z_order_get_delegate(System.IntPtr obj, System.IntPtr pd);
5377
5378
5379      public delegate int efl_access_component_z_order_get_api_delegate(System.IntPtr obj);
5380      public static Efl.Eo.FunctionWrapper<efl_access_component_z_order_get_api_delegate> efl_access_component_z_order_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_z_order_get_api_delegate>(_Module, "efl_access_component_z_order_get");
5381      private static int z_order_get(System.IntPtr obj, System.IntPtr pd)
5382     {
5383         Eina.Log.Debug("function efl_access_component_z_order_get was called");
5384         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5385         if(wrapper != null) {
5386                         int _ret_var = default(int);
5387             try {
5388                 _ret_var = ((Widget)wrapper).GetZOrder();
5389             } catch (Exception e) {
5390                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5391                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5392             }
5393         return _ret_var;
5394         } else {
5395             return efl_access_component_z_order_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5396         }
5397     }
5398     private static efl_access_component_z_order_get_delegate efl_access_component_z_order_get_static_delegate;
5399
5400
5401      private delegate Eina.Rect.NativeStruct efl_access_component_extents_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords);
5402
5403
5404      public delegate Eina.Rect.NativeStruct efl_access_component_extents_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords);
5405      public static Efl.Eo.FunctionWrapper<efl_access_component_extents_get_api_delegate> efl_access_component_extents_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_extents_get_api_delegate>(_Module, "efl_access_component_extents_get");
5406      private static Eina.Rect.NativeStruct extents_get(System.IntPtr obj, System.IntPtr pd,  bool screen_coords)
5407     {
5408         Eina.Log.Debug("function efl_access_component_extents_get was called");
5409         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5410         if(wrapper != null) {
5411                                                 Eina.Rect _ret_var = default(Eina.Rect);
5412             try {
5413                 _ret_var = ((Widget)wrapper).GetExtents( screen_coords);
5414             } catch (Exception e) {
5415                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5416                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5417             }
5418                         return _ret_var;
5419         } else {
5420             return efl_access_component_extents_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords);
5421         }
5422     }
5423     private static efl_access_component_extents_get_delegate efl_access_component_extents_get_static_delegate;
5424
5425
5426      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_extents_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   Eina.Rect.NativeStruct rect);
5427
5428
5429      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_extents_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   Eina.Rect.NativeStruct rect);
5430      public static Efl.Eo.FunctionWrapper<efl_access_component_extents_set_api_delegate> efl_access_component_extents_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_extents_set_api_delegate>(_Module, "efl_access_component_extents_set");
5431      private static bool extents_set(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,  Eina.Rect.NativeStruct rect)
5432     {
5433         Eina.Log.Debug("function efl_access_component_extents_set was called");
5434         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5435         if(wrapper != null) {
5436                             Eina.Rect _in_rect = rect;
5437                                             bool _ret_var = default(bool);
5438             try {
5439                 _ret_var = ((Widget)wrapper).SetExtents( screen_coords,  _in_rect);
5440             } catch (Exception e) {
5441                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5442                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5443             }
5444                                         return _ret_var;
5445         } else {
5446             return efl_access_component_extents_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  rect);
5447         }
5448     }
5449     private static efl_access_component_extents_set_delegate efl_access_component_extents_set_static_delegate;
5450
5451
5452      private delegate void efl_access_component_screen_position_get_delegate(System.IntPtr obj, System.IntPtr pd,   out int x,   out int y);
5453
5454
5455      public delegate void efl_access_component_screen_position_get_api_delegate(System.IntPtr obj,   out int x,   out int y);
5456      public static Efl.Eo.FunctionWrapper<efl_access_component_screen_position_get_api_delegate> efl_access_component_screen_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_screen_position_get_api_delegate>(_Module, "efl_access_component_screen_position_get");
5457      private static void screen_position_get(System.IntPtr obj, System.IntPtr pd,  out int x,  out int y)
5458     {
5459         Eina.Log.Debug("function efl_access_component_screen_position_get was called");
5460         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5461         if(wrapper != null) {
5462                                     x = default(int);        y = default(int);
5463             try {
5464                 ((Widget)wrapper).GetScreenPosition( out x,  out y);
5465             } catch (Exception e) {
5466                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5467                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5468             }
5469                                                 } else {
5470             efl_access_component_screen_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
5471         }
5472     }
5473     private static efl_access_component_screen_position_get_delegate efl_access_component_screen_position_get_static_delegate;
5474
5475
5476      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_screen_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   int x,   int y);
5477
5478
5479      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_screen_position_set_api_delegate(System.IntPtr obj,   int x,   int y);
5480      public static Efl.Eo.FunctionWrapper<efl_access_component_screen_position_set_api_delegate> efl_access_component_screen_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_screen_position_set_api_delegate>(_Module, "efl_access_component_screen_position_set");
5481      private static bool screen_position_set(System.IntPtr obj, System.IntPtr pd,  int x,  int y)
5482     {
5483         Eina.Log.Debug("function efl_access_component_screen_position_set was called");
5484         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5485         if(wrapper != null) {
5486                                                                         bool _ret_var = default(bool);
5487             try {
5488                 _ret_var = ((Widget)wrapper).SetScreenPosition( x,  y);
5489             } catch (Exception e) {
5490                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5491                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5492             }
5493                                         return _ret_var;
5494         } else {
5495             return efl_access_component_screen_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
5496         }
5497     }
5498     private static efl_access_component_screen_position_set_delegate efl_access_component_screen_position_set_static_delegate;
5499
5500
5501      private delegate void efl_access_component_socket_offset_get_delegate(System.IntPtr obj, System.IntPtr pd,   out int x,   out int y);
5502
5503
5504      public delegate void efl_access_component_socket_offset_get_api_delegate(System.IntPtr obj,   out int x,   out int y);
5505      public static Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_get_api_delegate> efl_access_component_socket_offset_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_get_api_delegate>(_Module, "efl_access_component_socket_offset_get");
5506      private static void socket_offset_get(System.IntPtr obj, System.IntPtr pd,  out int x,  out int y)
5507     {
5508         Eina.Log.Debug("function efl_access_component_socket_offset_get was called");
5509         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5510         if(wrapper != null) {
5511                                     x = default(int);        y = default(int);
5512             try {
5513                 ((Widget)wrapper).GetSocketOffset( out x,  out y);
5514             } catch (Exception e) {
5515                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5516                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5517             }
5518                                                 } else {
5519             efl_access_component_socket_offset_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out x,  out y);
5520         }
5521     }
5522     private static efl_access_component_socket_offset_get_delegate efl_access_component_socket_offset_get_static_delegate;
5523
5524
5525      private delegate void efl_access_component_socket_offset_set_delegate(System.IntPtr obj, System.IntPtr pd,   int x,   int y);
5526
5527
5528      public delegate void efl_access_component_socket_offset_set_api_delegate(System.IntPtr obj,   int x,   int y);
5529      public static Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_set_api_delegate> efl_access_component_socket_offset_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_socket_offset_set_api_delegate>(_Module, "efl_access_component_socket_offset_set");
5530      private static void socket_offset_set(System.IntPtr obj, System.IntPtr pd,  int x,  int y)
5531     {
5532         Eina.Log.Debug("function efl_access_component_socket_offset_set was called");
5533         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5534         if(wrapper != null) {
5535
5536             try {
5537                 ((Widget)wrapper).SetSocketOffset( x,  y);
5538             } catch (Exception e) {
5539                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5540                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5541             }
5542                                                 } else {
5543             efl_access_component_socket_offset_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
5544         }
5545     }
5546     private static efl_access_component_socket_offset_set_delegate efl_access_component_socket_offset_set_static_delegate;
5547
5548
5549      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_contains_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   int x,   int y);
5550
5551
5552      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_contains_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   int x,   int y);
5553      public static Efl.Eo.FunctionWrapper<efl_access_component_contains_api_delegate> efl_access_component_contains_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_contains_api_delegate>(_Module, "efl_access_component_contains");
5554      private static bool contains(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,  int x,  int y)
5555     {
5556         Eina.Log.Debug("function efl_access_component_contains was called");
5557         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5558         if(wrapper != null) {
5559                                                                                                 bool _ret_var = default(bool);
5560             try {
5561                 _ret_var = ((Widget)wrapper).Contains( screen_coords,  x,  y);
5562             } catch (Exception e) {
5563                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5564                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5565             }
5566                                                         return _ret_var;
5567         } else {
5568             return efl_access_component_contains_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  x,  y);
5569         }
5570     }
5571     private static efl_access_component_contains_delegate efl_access_component_contains_static_delegate;
5572
5573
5574      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_focus_grab_delegate(System.IntPtr obj, System.IntPtr pd);
5575
5576
5577      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_focus_grab_api_delegate(System.IntPtr obj);
5578      public static Efl.Eo.FunctionWrapper<efl_access_component_focus_grab_api_delegate> efl_access_component_focus_grab_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_focus_grab_api_delegate>(_Module, "efl_access_component_focus_grab");
5579      private static bool focus_grab(System.IntPtr obj, System.IntPtr pd)
5580     {
5581         Eina.Log.Debug("function efl_access_component_focus_grab was called");
5582         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5583         if(wrapper != null) {
5584                         bool _ret_var = default(bool);
5585             try {
5586                 _ret_var = ((Widget)wrapper).GrabFocus();
5587             } catch (Exception e) {
5588                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5589                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5590             }
5591         return _ret_var;
5592         } else {
5593             return efl_access_component_focus_grab_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5594         }
5595     }
5596     private static efl_access_component_focus_grab_delegate efl_access_component_focus_grab_static_delegate;
5597
5598
5599     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_access_component_accessible_at_point_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   int x,   int y);
5600
5601
5602     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_access_component_accessible_at_point_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool screen_coords,   int x,   int y);
5603      public static Efl.Eo.FunctionWrapper<efl_access_component_accessible_at_point_get_api_delegate> efl_access_component_accessible_at_point_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_accessible_at_point_get_api_delegate>(_Module, "efl_access_component_accessible_at_point_get");
5604      private static Efl.Object accessible_at_point_get(System.IntPtr obj, System.IntPtr pd,  bool screen_coords,  int x,  int y)
5605     {
5606         Eina.Log.Debug("function efl_access_component_accessible_at_point_get was called");
5607         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5608         if(wrapper != null) {
5609                                                                                                 Efl.Object _ret_var = default(Efl.Object);
5610             try {
5611                 _ret_var = ((Widget)wrapper).GetAccessibleAtPoint( screen_coords,  x,  y);
5612             } catch (Exception e) {
5613                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5614                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5615             }
5616                                                         return _ret_var;
5617         } else {
5618             return efl_access_component_accessible_at_point_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  screen_coords,  x,  y);
5619         }
5620     }
5621     private static efl_access_component_accessible_at_point_get_delegate efl_access_component_accessible_at_point_get_static_delegate;
5622
5623
5624      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_highlight_grab_delegate(System.IntPtr obj, System.IntPtr pd);
5625
5626
5627      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_highlight_grab_api_delegate(System.IntPtr obj);
5628      public static Efl.Eo.FunctionWrapper<efl_access_component_highlight_grab_api_delegate> efl_access_component_highlight_grab_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_highlight_grab_api_delegate>(_Module, "efl_access_component_highlight_grab");
5629      private static bool highlight_grab(System.IntPtr obj, System.IntPtr pd)
5630     {
5631         Eina.Log.Debug("function efl_access_component_highlight_grab was called");
5632         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5633         if(wrapper != null) {
5634                         bool _ret_var = default(bool);
5635             try {
5636                 _ret_var = ((Widget)wrapper).GrabHighlight();
5637             } catch (Exception e) {
5638                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5639                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5640             }
5641         return _ret_var;
5642         } else {
5643             return efl_access_component_highlight_grab_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5644         }
5645     }
5646     private static efl_access_component_highlight_grab_delegate efl_access_component_highlight_grab_static_delegate;
5647
5648
5649      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_component_highlight_clear_delegate(System.IntPtr obj, System.IntPtr pd);
5650
5651
5652      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_component_highlight_clear_api_delegate(System.IntPtr obj);
5653      public static Efl.Eo.FunctionWrapper<efl_access_component_highlight_clear_api_delegate> efl_access_component_highlight_clear_ptr = new Efl.Eo.FunctionWrapper<efl_access_component_highlight_clear_api_delegate>(_Module, "efl_access_component_highlight_clear");
5654      private static bool highlight_clear(System.IntPtr obj, System.IntPtr pd)
5655     {
5656         Eina.Log.Debug("function efl_access_component_highlight_clear was called");
5657         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5658         if(wrapper != null) {
5659                         bool _ret_var = default(bool);
5660             try {
5661                 _ret_var = ((Widget)wrapper).ClearHighlight();
5662             } catch (Exception e) {
5663                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5664                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5665             }
5666         return _ret_var;
5667         } else {
5668             return efl_access_component_highlight_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5669         }
5670     }
5671     private static efl_access_component_highlight_clear_delegate efl_access_component_highlight_clear_static_delegate;
5672
5673
5674      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_object_localized_role_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
5675
5676
5677      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_object_localized_role_name_get_api_delegate(System.IntPtr obj);
5678      public static Efl.Eo.FunctionWrapper<efl_access_object_localized_role_name_get_api_delegate> efl_access_object_localized_role_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_localized_role_name_get_api_delegate>(_Module, "efl_access_object_localized_role_name_get");
5679      private static System.String localized_role_name_get(System.IntPtr obj, System.IntPtr pd)
5680     {
5681         Eina.Log.Debug("function efl_access_object_localized_role_name_get was called");
5682         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5683         if(wrapper != null) {
5684                         System.String _ret_var = default(System.String);
5685             try {
5686                 _ret_var = ((Widget)wrapper).GetLocalizedRoleName();
5687             } catch (Exception e) {
5688                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5689                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5690             }
5691         return _ret_var;
5692         } else {
5693             return efl_access_object_localized_role_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5694         }
5695     }
5696     private static efl_access_object_localized_role_name_get_delegate efl_access_object_localized_role_name_get_static_delegate;
5697
5698
5699      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_object_i18n_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
5700
5701
5702      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_object_i18n_name_get_api_delegate(System.IntPtr obj);
5703      public static Efl.Eo.FunctionWrapper<efl_access_object_i18n_name_get_api_delegate> efl_access_object_i18n_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_i18n_name_get_api_delegate>(_Module, "efl_access_object_i18n_name_get");
5704      private static System.String i18n_name_get(System.IntPtr obj, System.IntPtr pd)
5705     {
5706         Eina.Log.Debug("function efl_access_object_i18n_name_get was called");
5707         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5708         if(wrapper != null) {
5709                         System.String _ret_var = default(System.String);
5710             try {
5711                 _ret_var = ((Widget)wrapper).GetI18nName();
5712             } catch (Exception e) {
5713                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5714                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5715             }
5716         return _ret_var;
5717         } else {
5718             return efl_access_object_i18n_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5719         }
5720     }
5721     private static efl_access_object_i18n_name_get_delegate efl_access_object_i18n_name_get_static_delegate;
5722
5723
5724      private delegate void efl_access_object_i18n_name_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String i18n_name);
5725
5726
5727      public delegate void efl_access_object_i18n_name_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String i18n_name);
5728      public static Efl.Eo.FunctionWrapper<efl_access_object_i18n_name_set_api_delegate> efl_access_object_i18n_name_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_i18n_name_set_api_delegate>(_Module, "efl_access_object_i18n_name_set");
5729      private static void i18n_name_set(System.IntPtr obj, System.IntPtr pd,  System.String i18n_name)
5730     {
5731         Eina.Log.Debug("function efl_access_object_i18n_name_set was called");
5732         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5733         if(wrapper != null) {
5734
5735             try {
5736                 ((Widget)wrapper).SetI18nName( i18n_name);
5737             } catch (Exception e) {
5738                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5739                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5740             }
5741                                 } else {
5742             efl_access_object_i18n_name_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  i18n_name);
5743         }
5744     }
5745     private static efl_access_object_i18n_name_set_delegate efl_access_object_i18n_name_set_static_delegate;
5746
5747
5748      private delegate void efl_access_object_name_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.ReadingInfoCb name_cb,   System.IntPtr data);
5749
5750
5751      public delegate void efl_access_object_name_cb_set_api_delegate(System.IntPtr obj,   Efl.Access.ReadingInfoCb name_cb,   System.IntPtr data);
5752      public static Efl.Eo.FunctionWrapper<efl_access_object_name_cb_set_api_delegate> efl_access_object_name_cb_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_name_cb_set_api_delegate>(_Module, "efl_access_object_name_cb_set");
5753      private static void name_cb_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoCb name_cb,  System.IntPtr data)
5754     {
5755         Eina.Log.Debug("function efl_access_object_name_cb_set was called");
5756         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5757         if(wrapper != null) {
5758
5759             try {
5760                 ((Widget)wrapper).SetNameCb( name_cb,  data);
5761             } catch (Exception e) {
5762                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5763                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5764             }
5765                                                 } else {
5766             efl_access_object_name_cb_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name_cb,  data);
5767         }
5768     }
5769     private static efl_access_object_name_cb_set_delegate efl_access_object_name_cb_set_static_delegate;
5770
5771
5772      private delegate Efl.Access.RelationSet efl_access_object_relation_set_get_delegate(System.IntPtr obj, System.IntPtr pd);
5773
5774
5775      public delegate Efl.Access.RelationSet efl_access_object_relation_set_get_api_delegate(System.IntPtr obj);
5776      public static Efl.Eo.FunctionWrapper<efl_access_object_relation_set_get_api_delegate> efl_access_object_relation_set_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_relation_set_get_api_delegate>(_Module, "efl_access_object_relation_set_get");
5777      private static Efl.Access.RelationSet relation_set_get(System.IntPtr obj, System.IntPtr pd)
5778     {
5779         Eina.Log.Debug("function efl_access_object_relation_set_get was called");
5780         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5781         if(wrapper != null) {
5782                         Efl.Access.RelationSet _ret_var = default(Efl.Access.RelationSet);
5783             try {
5784                 _ret_var = ((Widget)wrapper).GetRelationSet();
5785             } catch (Exception e) {
5786                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5787                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5788             }
5789         return _ret_var;
5790         } else {
5791             return efl_access_object_relation_set_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5792         }
5793     }
5794     private static efl_access_object_relation_set_get_delegate efl_access_object_relation_set_get_static_delegate;
5795
5796
5797      private delegate Efl.Access.Role efl_access_object_role_get_delegate(System.IntPtr obj, System.IntPtr pd);
5798
5799
5800      public delegate Efl.Access.Role efl_access_object_role_get_api_delegate(System.IntPtr obj);
5801      public static Efl.Eo.FunctionWrapper<efl_access_object_role_get_api_delegate> efl_access_object_role_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_role_get_api_delegate>(_Module, "efl_access_object_role_get");
5802      private static Efl.Access.Role role_get(System.IntPtr obj, System.IntPtr pd)
5803     {
5804         Eina.Log.Debug("function efl_access_object_role_get was called");
5805         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5806         if(wrapper != null) {
5807                         Efl.Access.Role _ret_var = default(Efl.Access.Role);
5808             try {
5809                 _ret_var = ((Widget)wrapper).GetRole();
5810             } catch (Exception e) {
5811                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5812                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5813             }
5814         return _ret_var;
5815         } else {
5816             return efl_access_object_role_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5817         }
5818     }
5819     private static efl_access_object_role_get_delegate efl_access_object_role_get_static_delegate;
5820
5821
5822      private delegate void efl_access_object_role_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.Role role);
5823
5824
5825      public delegate void efl_access_object_role_set_api_delegate(System.IntPtr obj,   Efl.Access.Role role);
5826      public static Efl.Eo.FunctionWrapper<efl_access_object_role_set_api_delegate> efl_access_object_role_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_role_set_api_delegate>(_Module, "efl_access_object_role_set");
5827      private static void role_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.Role role)
5828     {
5829         Eina.Log.Debug("function efl_access_object_role_set was called");
5830         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5831         if(wrapper != null) {
5832
5833             try {
5834                 ((Widget)wrapper).SetRole( role);
5835             } catch (Exception e) {
5836                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5837                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5838             }
5839                                 } else {
5840             efl_access_object_role_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  role);
5841         }
5842     }
5843     private static efl_access_object_role_set_delegate efl_access_object_role_set_static_delegate;
5844
5845
5846     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Access.IObject efl_access_object_access_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
5847
5848
5849     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Access.IObject efl_access_object_access_parent_get_api_delegate(System.IntPtr obj);
5850      public static Efl.Eo.FunctionWrapper<efl_access_object_access_parent_get_api_delegate> efl_access_object_access_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_access_parent_get_api_delegate>(_Module, "efl_access_object_access_parent_get");
5851      private static Efl.Access.IObject access_parent_get(System.IntPtr obj, System.IntPtr pd)
5852     {
5853         Eina.Log.Debug("function efl_access_object_access_parent_get was called");
5854         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5855         if(wrapper != null) {
5856                         Efl.Access.IObject _ret_var = default(Efl.Access.IObject);
5857             try {
5858                 _ret_var = ((Widget)wrapper).GetAccessParent();
5859             } catch (Exception e) {
5860                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5861                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5862             }
5863         return _ret_var;
5864         } else {
5865             return efl_access_object_access_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5866         }
5867     }
5868     private static efl_access_object_access_parent_get_delegate efl_access_object_access_parent_get_static_delegate;
5869
5870
5871      private delegate void efl_access_object_access_parent_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject parent);
5872
5873
5874      public delegate void efl_access_object_access_parent_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject parent);
5875      public static Efl.Eo.FunctionWrapper<efl_access_object_access_parent_set_api_delegate> efl_access_object_access_parent_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_access_parent_set_api_delegate>(_Module, "efl_access_object_access_parent_set");
5876      private static void access_parent_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.IObject parent)
5877     {
5878         Eina.Log.Debug("function efl_access_object_access_parent_set was called");
5879         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5880         if(wrapper != null) {
5881
5882             try {
5883                 ((Widget)wrapper).SetAccessParent( parent);
5884             } catch (Exception e) {
5885                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5886                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5887             }
5888                                 } else {
5889             efl_access_object_access_parent_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  parent);
5890         }
5891     }
5892     private static efl_access_object_access_parent_set_delegate efl_access_object_access_parent_set_static_delegate;
5893
5894
5895      private delegate void efl_access_object_description_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.ReadingInfoCb description_cb,   System.IntPtr data);
5896
5897
5898      public delegate void efl_access_object_description_cb_set_api_delegate(System.IntPtr obj,   Efl.Access.ReadingInfoCb description_cb,   System.IntPtr data);
5899      public static Efl.Eo.FunctionWrapper<efl_access_object_description_cb_set_api_delegate> efl_access_object_description_cb_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_description_cb_set_api_delegate>(_Module, "efl_access_object_description_cb_set");
5900      private static void description_cb_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoCb description_cb,  System.IntPtr data)
5901     {
5902         Eina.Log.Debug("function efl_access_object_description_cb_set was called");
5903         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5904         if(wrapper != null) {
5905
5906             try {
5907                 ((Widget)wrapper).SetDescriptionCb( description_cb,  data);
5908             } catch (Exception e) {
5909                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5910                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5911             }
5912                                                 } else {
5913             efl_access_object_description_cb_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  description_cb,  data);
5914         }
5915     }
5916     private static efl_access_object_description_cb_set_delegate efl_access_object_description_cb_set_static_delegate;
5917
5918
5919      private delegate void efl_access_object_gesture_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.GestureCb gesture_cb,   System.IntPtr data);
5920
5921
5922      public delegate void efl_access_object_gesture_cb_set_api_delegate(System.IntPtr obj,   Efl.Access.GestureCb gesture_cb,   System.IntPtr data);
5923      public static Efl.Eo.FunctionWrapper<efl_access_object_gesture_cb_set_api_delegate> efl_access_object_gesture_cb_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_gesture_cb_set_api_delegate>(_Module, "efl_access_object_gesture_cb_set");
5924      private static void gesture_cb_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.GestureCb gesture_cb,  System.IntPtr data)
5925     {
5926         Eina.Log.Debug("function efl_access_object_gesture_cb_set was called");
5927         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5928         if(wrapper != null) {
5929
5930             try {
5931                 ((Widget)wrapper).SetGestureCb( gesture_cb,  data);
5932             } catch (Exception e) {
5933                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5934                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5935             }
5936                                                 } else {
5937             efl_access_object_gesture_cb_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  gesture_cb,  data);
5938         }
5939     }
5940     private static efl_access_object_gesture_cb_set_delegate efl_access_object_gesture_cb_set_static_delegate;
5941
5942
5943      private delegate System.IntPtr efl_access_object_access_children_get_delegate(System.IntPtr obj, System.IntPtr pd);
5944
5945
5946      public delegate System.IntPtr efl_access_object_access_children_get_api_delegate(System.IntPtr obj);
5947      public static Efl.Eo.FunctionWrapper<efl_access_object_access_children_get_api_delegate> efl_access_object_access_children_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_access_children_get_api_delegate>(_Module, "efl_access_object_access_children_get");
5948      private static System.IntPtr access_children_get(System.IntPtr obj, System.IntPtr pd)
5949     {
5950         Eina.Log.Debug("function efl_access_object_access_children_get was called");
5951         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5952         if(wrapper != null) {
5953                         Eina.List<Efl.Access.IObject> _ret_var = default(Eina.List<Efl.Access.IObject>);
5954             try {
5955                 _ret_var = ((Widget)wrapper).GetAccessChildren();
5956             } catch (Exception e) {
5957                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5958                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5959             }
5960         _ret_var.Own = false; return _ret_var.Handle;
5961         } else {
5962             return efl_access_object_access_children_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5963         }
5964     }
5965     private static efl_access_object_access_children_get_delegate efl_access_object_access_children_get_static_delegate;
5966
5967
5968      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_object_role_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
5969
5970
5971      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_object_role_name_get_api_delegate(System.IntPtr obj);
5972      public static Efl.Eo.FunctionWrapper<efl_access_object_role_name_get_api_delegate> efl_access_object_role_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_role_name_get_api_delegate>(_Module, "efl_access_object_role_name_get");
5973      private static System.String role_name_get(System.IntPtr obj, System.IntPtr pd)
5974     {
5975         Eina.Log.Debug("function efl_access_object_role_name_get was called");
5976         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
5977         if(wrapper != null) {
5978                         System.String _ret_var = default(System.String);
5979             try {
5980                 _ret_var = ((Widget)wrapper).GetRoleName();
5981             } catch (Exception e) {
5982                 Eina.Log.Warning($"Callback error: {e.ToString()}");
5983                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5984             }
5985         return _ret_var;
5986         } else {
5987             return efl_access_object_role_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5988         }
5989     }
5990     private static efl_access_object_role_name_get_delegate efl_access_object_role_name_get_static_delegate;
5991
5992
5993      private delegate System.IntPtr efl_access_object_attributes_get_delegate(System.IntPtr obj, System.IntPtr pd);
5994
5995
5996      public delegate System.IntPtr efl_access_object_attributes_get_api_delegate(System.IntPtr obj);
5997      public static Efl.Eo.FunctionWrapper<efl_access_object_attributes_get_api_delegate> efl_access_object_attributes_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_attributes_get_api_delegate>(_Module, "efl_access_object_attributes_get");
5998      private static System.IntPtr attributes_get(System.IntPtr obj, System.IntPtr pd)
5999     {
6000         Eina.Log.Debug("function efl_access_object_attributes_get was called");
6001         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6002         if(wrapper != null) {
6003                         Eina.List<Efl.Access.Attribute> _ret_var = default(Eina.List<Efl.Access.Attribute>);
6004             try {
6005                 _ret_var = ((Widget)wrapper).GetAttributes();
6006             } catch (Exception e) {
6007                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6008                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6009             }
6010         _ret_var.Own = false; _ret_var.OwnContent = false; return _ret_var.Handle;
6011         } else {
6012             return efl_access_object_attributes_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6013         }
6014     }
6015     private static efl_access_object_attributes_get_delegate efl_access_object_attributes_get_static_delegate;
6016
6017
6018      private delegate Efl.Access.ReadingInfoTypeMask efl_access_object_reading_info_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
6019
6020
6021      public delegate Efl.Access.ReadingInfoTypeMask efl_access_object_reading_info_type_get_api_delegate(System.IntPtr obj);
6022      public static Efl.Eo.FunctionWrapper<efl_access_object_reading_info_type_get_api_delegate> efl_access_object_reading_info_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_reading_info_type_get_api_delegate>(_Module, "efl_access_object_reading_info_type_get");
6023      private static Efl.Access.ReadingInfoTypeMask reading_info_type_get(System.IntPtr obj, System.IntPtr pd)
6024     {
6025         Eina.Log.Debug("function efl_access_object_reading_info_type_get was called");
6026         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6027         if(wrapper != null) {
6028                         Efl.Access.ReadingInfoTypeMask _ret_var = default(Efl.Access.ReadingInfoTypeMask);
6029             try {
6030                 _ret_var = ((Widget)wrapper).GetReadingInfoType();
6031             } catch (Exception e) {
6032                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6033                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6034             }
6035         return _ret_var;
6036         } else {
6037             return efl_access_object_reading_info_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6038         }
6039     }
6040     private static efl_access_object_reading_info_type_get_delegate efl_access_object_reading_info_type_get_static_delegate;
6041
6042
6043      private delegate void efl_access_object_reading_info_type_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.ReadingInfoTypeMask reading_info);
6044
6045
6046      public delegate void efl_access_object_reading_info_type_set_api_delegate(System.IntPtr obj,   Efl.Access.ReadingInfoTypeMask reading_info);
6047      public static Efl.Eo.FunctionWrapper<efl_access_object_reading_info_type_set_api_delegate> efl_access_object_reading_info_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_reading_info_type_set_api_delegate>(_Module, "efl_access_object_reading_info_type_set");
6048      private static void reading_info_type_set(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoTypeMask reading_info)
6049     {
6050         Eina.Log.Debug("function efl_access_object_reading_info_type_set was called");
6051         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6052         if(wrapper != null) {
6053
6054             try {
6055                 ((Widget)wrapper).SetReadingInfoType( reading_info);
6056             } catch (Exception e) {
6057                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6058                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6059             }
6060                                 } else {
6061             efl_access_object_reading_info_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  reading_info);
6062         }
6063     }
6064     private static efl_access_object_reading_info_type_set_delegate efl_access_object_reading_info_type_set_static_delegate;
6065
6066
6067      private delegate int efl_access_object_index_in_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
6068
6069
6070      public delegate int efl_access_object_index_in_parent_get_api_delegate(System.IntPtr obj);
6071      public static Efl.Eo.FunctionWrapper<efl_access_object_index_in_parent_get_api_delegate> efl_access_object_index_in_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_index_in_parent_get_api_delegate>(_Module, "efl_access_object_index_in_parent_get");
6072      private static int index_in_parent_get(System.IntPtr obj, System.IntPtr pd)
6073     {
6074         Eina.Log.Debug("function efl_access_object_index_in_parent_get was called");
6075         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6076         if(wrapper != null) {
6077                         int _ret_var = default(int);
6078             try {
6079                 _ret_var = ((Widget)wrapper).GetIndexInParent();
6080             } catch (Exception e) {
6081                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6082                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6083             }
6084         return _ret_var;
6085         } else {
6086             return efl_access_object_index_in_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6087         }
6088     }
6089     private static efl_access_object_index_in_parent_get_delegate efl_access_object_index_in_parent_get_static_delegate;
6090
6091
6092      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_object_description_get_delegate(System.IntPtr obj, System.IntPtr pd);
6093
6094
6095      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_object_description_get_api_delegate(System.IntPtr obj);
6096      public static Efl.Eo.FunctionWrapper<efl_access_object_description_get_api_delegate> efl_access_object_description_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_description_get_api_delegate>(_Module, "efl_access_object_description_get");
6097      private static System.String description_get(System.IntPtr obj, System.IntPtr pd)
6098     {
6099         Eina.Log.Debug("function efl_access_object_description_get was called");
6100         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6101         if(wrapper != null) {
6102                         System.String _ret_var = default(System.String);
6103             try {
6104                 _ret_var = ((Widget)wrapper).GetDescription();
6105             } catch (Exception e) {
6106                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6107                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6108             }
6109         return _ret_var;
6110         } else {
6111             return efl_access_object_description_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6112         }
6113     }
6114     private static efl_access_object_description_get_delegate efl_access_object_description_get_static_delegate;
6115
6116
6117      private delegate void efl_access_object_description_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String description);
6118
6119
6120      public delegate void efl_access_object_description_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String description);
6121      public static Efl.Eo.FunctionWrapper<efl_access_object_description_set_api_delegate> efl_access_object_description_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_description_set_api_delegate>(_Module, "efl_access_object_description_set");
6122      private static void description_set(System.IntPtr obj, System.IntPtr pd,  System.String description)
6123     {
6124         Eina.Log.Debug("function efl_access_object_description_set was called");
6125         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6126         if(wrapper != null) {
6127
6128             try {
6129                 ((Widget)wrapper).SetDescription( description);
6130             } catch (Exception e) {
6131                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6132                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6133             }
6134                                 } else {
6135             efl_access_object_description_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  description);
6136         }
6137     }
6138     private static efl_access_object_description_set_delegate efl_access_object_description_set_static_delegate;
6139
6140
6141      private delegate Efl.Access.StateSet efl_access_object_state_set_get_delegate(System.IntPtr obj, System.IntPtr pd);
6142
6143
6144      public delegate Efl.Access.StateSet efl_access_object_state_set_get_api_delegate(System.IntPtr obj);
6145      public static Efl.Eo.FunctionWrapper<efl_access_object_state_set_get_api_delegate> efl_access_object_state_set_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_state_set_get_api_delegate>(_Module, "efl_access_object_state_set_get");
6146      private static Efl.Access.StateSet state_set_get(System.IntPtr obj, System.IntPtr pd)
6147     {
6148         Eina.Log.Debug("function efl_access_object_state_set_get was called");
6149         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6150         if(wrapper != null) {
6151                         Efl.Access.StateSet _ret_var = default(Efl.Access.StateSet);
6152             try {
6153                 _ret_var = ((Widget)wrapper).GetStateSet();
6154             } catch (Exception e) {
6155                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6156                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6157             }
6158         return _ret_var;
6159         } else {
6160             return efl_access_object_state_set_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6161         }
6162     }
6163     private static efl_access_object_state_set_get_delegate efl_access_object_state_set_get_static_delegate;
6164
6165
6166      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_object_can_highlight_get_delegate(System.IntPtr obj, System.IntPtr pd);
6167
6168
6169      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_object_can_highlight_get_api_delegate(System.IntPtr obj);
6170      public static Efl.Eo.FunctionWrapper<efl_access_object_can_highlight_get_api_delegate> efl_access_object_can_highlight_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_can_highlight_get_api_delegate>(_Module, "efl_access_object_can_highlight_get");
6171      private static bool can_highlight_get(System.IntPtr obj, System.IntPtr pd)
6172     {
6173         Eina.Log.Debug("function efl_access_object_can_highlight_get was called");
6174         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6175         if(wrapper != null) {
6176                         bool _ret_var = default(bool);
6177             try {
6178                 _ret_var = ((Widget)wrapper).GetCanHighlight();
6179             } catch (Exception e) {
6180                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6181                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6182             }
6183         return _ret_var;
6184         } else {
6185             return efl_access_object_can_highlight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6186         }
6187     }
6188     private static efl_access_object_can_highlight_get_delegate efl_access_object_can_highlight_get_static_delegate;
6189
6190
6191      private delegate void efl_access_object_can_highlight_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool can_highlight);
6192
6193
6194      public delegate void efl_access_object_can_highlight_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool can_highlight);
6195      public static Efl.Eo.FunctionWrapper<efl_access_object_can_highlight_set_api_delegate> efl_access_object_can_highlight_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_can_highlight_set_api_delegate>(_Module, "efl_access_object_can_highlight_set");
6196      private static void can_highlight_set(System.IntPtr obj, System.IntPtr pd,  bool can_highlight)
6197     {
6198         Eina.Log.Debug("function efl_access_object_can_highlight_set was called");
6199         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6200         if(wrapper != null) {
6201
6202             try {
6203                 ((Widget)wrapper).SetCanHighlight( can_highlight);
6204             } catch (Exception e) {
6205                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6206                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6207             }
6208                                 } else {
6209             efl_access_object_can_highlight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  can_highlight);
6210         }
6211     }
6212     private static efl_access_object_can_highlight_set_delegate efl_access_object_can_highlight_set_static_delegate;
6213
6214
6215      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_access_object_translation_domain_get_delegate(System.IntPtr obj, System.IntPtr pd);
6216
6217
6218      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_access_object_translation_domain_get_api_delegate(System.IntPtr obj);
6219      public static Efl.Eo.FunctionWrapper<efl_access_object_translation_domain_get_api_delegate> efl_access_object_translation_domain_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_translation_domain_get_api_delegate>(_Module, "efl_access_object_translation_domain_get");
6220      private static System.String translation_domain_get(System.IntPtr obj, System.IntPtr pd)
6221     {
6222         Eina.Log.Debug("function efl_access_object_translation_domain_get was called");
6223         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6224         if(wrapper != null) {
6225                         System.String _ret_var = default(System.String);
6226             try {
6227                 _ret_var = ((Widget)wrapper).GetTranslationDomain();
6228             } catch (Exception e) {
6229                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6230                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6231             }
6232         return _ret_var;
6233         } else {
6234             return efl_access_object_translation_domain_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6235         }
6236     }
6237     private static efl_access_object_translation_domain_get_delegate efl_access_object_translation_domain_get_static_delegate;
6238
6239
6240      private delegate void efl_access_object_translation_domain_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String domain);
6241
6242
6243      public delegate void efl_access_object_translation_domain_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String domain);
6244      public static Efl.Eo.FunctionWrapper<efl_access_object_translation_domain_set_api_delegate> efl_access_object_translation_domain_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_translation_domain_set_api_delegate>(_Module, "efl_access_object_translation_domain_set");
6245      private static void translation_domain_set(System.IntPtr obj, System.IntPtr pd,  System.String domain)
6246     {
6247         Eina.Log.Debug("function efl_access_object_translation_domain_set was called");
6248         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6249         if(wrapper != null) {
6250
6251             try {
6252                 ((Widget)wrapper).SetTranslationDomain( domain);
6253             } catch (Exception e) {
6254                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6255                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6256             }
6257                                 } else {
6258             efl_access_object_translation_domain_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  domain);
6259         }
6260     }
6261     private static efl_access_object_translation_domain_set_delegate efl_access_object_translation_domain_set_static_delegate;
6262
6263
6264     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_access_object_access_root_get_delegate();
6265
6266
6267     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_access_object_access_root_get_api_delegate();
6268      public static Efl.Eo.FunctionWrapper<efl_access_object_access_root_get_api_delegate> efl_access_object_access_root_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_access_root_get_api_delegate>(_Module, "efl_access_object_access_root_get");
6269      private static Efl.Object access_root_get(System.IntPtr obj, System.IntPtr pd)
6270     {
6271         Eina.Log.Debug("function efl_access_object_access_root_get was called");
6272         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6273         if(wrapper != null) {
6274                         Efl.Object _ret_var = default(Efl.Object);
6275             try {
6276                 _ret_var = Widget.GetAccessRoot();
6277             } catch (Exception e) {
6278                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6279                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6280             }
6281         return _ret_var;
6282         } else {
6283             return efl_access_object_access_root_get_ptr.Value.Delegate();
6284         }
6285     }
6286
6287
6288      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_object_gesture_do_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.GestureInfo.NativeStruct gesture_info);
6289
6290
6291      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_object_gesture_do_api_delegate(System.IntPtr obj,   Efl.Access.GestureInfo.NativeStruct gesture_info);
6292      public static Efl.Eo.FunctionWrapper<efl_access_object_gesture_do_api_delegate> efl_access_object_gesture_do_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_gesture_do_api_delegate>(_Module, "efl_access_object_gesture_do");
6293      private static bool gesture_do(System.IntPtr obj, System.IntPtr pd,  Efl.Access.GestureInfo.NativeStruct gesture_info)
6294     {
6295         Eina.Log.Debug("function efl_access_object_gesture_do was called");
6296         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6297         if(wrapper != null) {
6298                     Efl.Access.GestureInfo _in_gesture_info = gesture_info;
6299                             bool _ret_var = default(bool);
6300             try {
6301                 _ret_var = ((Widget)wrapper).GestureDo( _in_gesture_info);
6302             } catch (Exception e) {
6303                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6304                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6305             }
6306                         return _ret_var;
6307         } else {
6308             return efl_access_object_gesture_do_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  gesture_info);
6309         }
6310     }
6311     private static efl_access_object_gesture_do_delegate efl_access_object_gesture_do_static_delegate;
6312
6313
6314      private delegate void efl_access_object_attribute_append_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String value);
6315
6316
6317      public delegate void efl_access_object_attribute_append_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String value);
6318      public static Efl.Eo.FunctionWrapper<efl_access_object_attribute_append_api_delegate> efl_access_object_attribute_append_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_attribute_append_api_delegate>(_Module, "efl_access_object_attribute_append");
6319      private static void attribute_append(System.IntPtr obj, System.IntPtr pd,  System.String key,  System.String value)
6320     {
6321         Eina.Log.Debug("function efl_access_object_attribute_append was called");
6322         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6323         if(wrapper != null) {
6324
6325             try {
6326                 ((Widget)wrapper).AppendAttribute( key,  value);
6327             } catch (Exception e) {
6328                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6329                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6330             }
6331                                                 } else {
6332             efl_access_object_attribute_append_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key,  value);
6333         }
6334     }
6335     private static efl_access_object_attribute_append_delegate efl_access_object_attribute_append_static_delegate;
6336
6337
6338      private delegate void efl_access_object_attribute_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key);
6339
6340
6341      public delegate void efl_access_object_attribute_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key);
6342      public static Efl.Eo.FunctionWrapper<efl_access_object_attribute_del_api_delegate> efl_access_object_attribute_del_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_attribute_del_api_delegate>(_Module, "efl_access_object_attribute_del");
6343      private static void attribute_del(System.IntPtr obj, System.IntPtr pd,  System.String key)
6344     {
6345         Eina.Log.Debug("function efl_access_object_attribute_del was called");
6346         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6347         if(wrapper != null) {
6348
6349             try {
6350                 ((Widget)wrapper).DelAttribute( key);
6351             } catch (Exception e) {
6352                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6353                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6354             }
6355                                 } else {
6356             efl_access_object_attribute_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key);
6357         }
6358     }
6359     private static efl_access_object_attribute_del_delegate efl_access_object_attribute_del_static_delegate;
6360
6361
6362      private delegate void efl_access_object_attributes_clear_delegate(System.IntPtr obj, System.IntPtr pd);
6363
6364
6365      public delegate void efl_access_object_attributes_clear_api_delegate(System.IntPtr obj);
6366      public static Efl.Eo.FunctionWrapper<efl_access_object_attributes_clear_api_delegate> efl_access_object_attributes_clear_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_attributes_clear_api_delegate>(_Module, "efl_access_object_attributes_clear");
6367      private static void attributes_clear(System.IntPtr obj, System.IntPtr pd)
6368     {
6369         Eina.Log.Debug("function efl_access_object_attributes_clear was called");
6370         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6371         if(wrapper != null) {
6372
6373             try {
6374                 ((Widget)wrapper).ClearAttributes();
6375             } catch (Exception e) {
6376                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6377                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6378             }
6379                 } else {
6380             efl_access_object_attributes_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6381         }
6382     }
6383     private static efl_access_object_attributes_clear_delegate efl_access_object_attributes_clear_static_delegate;
6384
6385
6386      private delegate Efl.Access.Event.Handler efl_access_object_event_handler_add_delegate(  Efl.EventCb cb,   System.IntPtr data);
6387
6388
6389      public delegate Efl.Access.Event.Handler efl_access_object_event_handler_add_api_delegate(  Efl.EventCb cb,   System.IntPtr data);
6390      public static Efl.Eo.FunctionWrapper<efl_access_object_event_handler_add_api_delegate> efl_access_object_event_handler_add_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_event_handler_add_api_delegate>(_Module, "efl_access_object_event_handler_add");
6391      private static Efl.Access.Event.Handler event_handler_add(System.IntPtr obj, System.IntPtr pd,  Efl.EventCb cb,  System.IntPtr data)
6392     {
6393         Eina.Log.Debug("function efl_access_object_event_handler_add was called");
6394         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6395         if(wrapper != null) {
6396                                                                         Efl.Access.Event.Handler _ret_var = default(Efl.Access.Event.Handler);
6397             try {
6398                 _ret_var = Widget.AddEventHandler( cb,  data);
6399             } catch (Exception e) {
6400                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6401                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6402             }
6403                                         return _ret_var;
6404         } else {
6405             return efl_access_object_event_handler_add_ptr.Value.Delegate( cb,  data);
6406         }
6407     }
6408
6409
6410      private delegate void efl_access_object_event_handler_del_delegate(  Efl.Access.Event.Handler handler);
6411
6412
6413      public delegate void efl_access_object_event_handler_del_api_delegate(  Efl.Access.Event.Handler handler);
6414      public static Efl.Eo.FunctionWrapper<efl_access_object_event_handler_del_api_delegate> efl_access_object_event_handler_del_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_event_handler_del_api_delegate>(_Module, "efl_access_object_event_handler_del");
6415      private static void event_handler_del(System.IntPtr obj, System.IntPtr pd,  Efl.Access.Event.Handler handler)
6416     {
6417         Eina.Log.Debug("function efl_access_object_event_handler_del was called");
6418         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6419         if(wrapper != null) {
6420
6421             try {
6422                 Widget.DelEventHandler( handler);
6423             } catch (Exception e) {
6424                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6425                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6426             }
6427                                 } else {
6428             efl_access_object_event_handler_del_ptr.Value.Delegate( handler);
6429         }
6430     }
6431
6432
6433      private delegate void efl_access_object_event_emit_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject accessible,   System.IntPtr kw_event,   System.IntPtr event_info);
6434
6435
6436      public delegate void efl_access_object_event_emit_api_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject accessible,   System.IntPtr kw_event,   System.IntPtr event_info);
6437      public static Efl.Eo.FunctionWrapper<efl_access_object_event_emit_api_delegate> efl_access_object_event_emit_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_event_emit_api_delegate>(_Module, "efl_access_object_event_emit");
6438      private static void event_emit(System.IntPtr obj, System.IntPtr pd,  Efl.Access.IObject accessible,  System.IntPtr kw_event,  System.IntPtr event_info)
6439     {
6440         Eina.Log.Debug("function efl_access_object_event_emit was called");
6441         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6442         if(wrapper != null) {
6443                             var _in_kw_event = Eina.PrimitiveConversion.PointerToManaged<Efl.EventDescription>(kw_event);
6444
6445             try {
6446                 Widget.EmitEvent( accessible,  _in_kw_event,  event_info);
6447             } catch (Exception e) {
6448                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6449                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6450             }
6451                                                                 } else {
6452             efl_access_object_event_emit_ptr.Value.Delegate( accessible,  kw_event,  event_info);
6453         }
6454     }
6455
6456
6457      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_object_relationship_append_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject relation_object);
6458
6459
6460      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_object_relationship_append_api_delegate(System.IntPtr obj,   Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject relation_object);
6461      public static Efl.Eo.FunctionWrapper<efl_access_object_relationship_append_api_delegate> efl_access_object_relationship_append_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_relationship_append_api_delegate>(_Module, "efl_access_object_relationship_append");
6462      private static bool relationship_append(System.IntPtr obj, System.IntPtr pd,  Efl.Access.RelationType type,  Efl.Access.IObject relation_object)
6463     {
6464         Eina.Log.Debug("function efl_access_object_relationship_append was called");
6465         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6466         if(wrapper != null) {
6467                                                                         bool _ret_var = default(bool);
6468             try {
6469                 _ret_var = ((Widget)wrapper).AppendRelationship( type,  relation_object);
6470             } catch (Exception e) {
6471                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6472                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6473             }
6474                                         return _ret_var;
6475         } else {
6476             return efl_access_object_relationship_append_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  relation_object);
6477         }
6478     }
6479     private static efl_access_object_relationship_append_delegate efl_access_object_relationship_append_static_delegate;
6480
6481
6482      private delegate void efl_access_object_relationship_remove_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject relation_object);
6483
6484
6485      public delegate void efl_access_object_relationship_remove_api_delegate(System.IntPtr obj,   Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Access.IObjectConcrete, Efl.Eo.NonOwnTag>))]  Efl.Access.IObject relation_object);
6486      public static Efl.Eo.FunctionWrapper<efl_access_object_relationship_remove_api_delegate> efl_access_object_relationship_remove_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_relationship_remove_api_delegate>(_Module, "efl_access_object_relationship_remove");
6487      private static void relationship_remove(System.IntPtr obj, System.IntPtr pd,  Efl.Access.RelationType type,  Efl.Access.IObject relation_object)
6488     {
6489         Eina.Log.Debug("function efl_access_object_relationship_remove was called");
6490         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6491         if(wrapper != null) {
6492
6493             try {
6494                 ((Widget)wrapper).RelationshipRemove( type,  relation_object);
6495             } catch (Exception e) {
6496                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6497                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6498             }
6499                                                 } else {
6500             efl_access_object_relationship_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  relation_object);
6501         }
6502     }
6503     private static efl_access_object_relationship_remove_delegate efl_access_object_relationship_remove_static_delegate;
6504
6505
6506      private delegate void efl_access_object_relationships_clear_delegate(System.IntPtr obj, System.IntPtr pd);
6507
6508
6509      public delegate void efl_access_object_relationships_clear_api_delegate(System.IntPtr obj);
6510      public static Efl.Eo.FunctionWrapper<efl_access_object_relationships_clear_api_delegate> efl_access_object_relationships_clear_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_relationships_clear_api_delegate>(_Module, "efl_access_object_relationships_clear");
6511      private static void relationships_clear(System.IntPtr obj, System.IntPtr pd)
6512     {
6513         Eina.Log.Debug("function efl_access_object_relationships_clear was called");
6514         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6515         if(wrapper != null) {
6516
6517             try {
6518                 ((Widget)wrapper).ClearRelationships();
6519             } catch (Exception e) {
6520                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6521                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6522             }
6523                 } else {
6524             efl_access_object_relationships_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6525         }
6526     }
6527     private static efl_access_object_relationships_clear_delegate efl_access_object_relationships_clear_static_delegate;
6528
6529
6530      private delegate void efl_access_object_state_notify_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Access.StateSet state_types_mask,  [MarshalAs(UnmanagedType.U1)]  bool recursive);
6531
6532
6533      public delegate void efl_access_object_state_notify_api_delegate(System.IntPtr obj,   Efl.Access.StateSet state_types_mask,  [MarshalAs(UnmanagedType.U1)]  bool recursive);
6534      public static Efl.Eo.FunctionWrapper<efl_access_object_state_notify_api_delegate> efl_access_object_state_notify_ptr = new Efl.Eo.FunctionWrapper<efl_access_object_state_notify_api_delegate>(_Module, "efl_access_object_state_notify");
6535      private static void state_notify(System.IntPtr obj, System.IntPtr pd,  Efl.Access.StateSet state_types_mask,  bool recursive)
6536     {
6537         Eina.Log.Debug("function efl_access_object_state_notify was called");
6538         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6539         if(wrapper != null) {
6540
6541             try {
6542                 ((Widget)wrapper).StateNotify( state_types_mask,  recursive);
6543             } catch (Exception e) {
6544                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6545                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6546             }
6547                                                 } else {
6548             efl_access_object_state_notify_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  state_types_mask,  recursive);
6549         }
6550     }
6551     private static efl_access_object_state_notify_delegate efl_access_object_state_notify_static_delegate;
6552
6553
6554      private delegate Efl.Access.ActionData efl_access_widget_action_elm_actions_get_delegate(System.IntPtr obj, System.IntPtr pd);
6555
6556
6557      public delegate Efl.Access.ActionData efl_access_widget_action_elm_actions_get_api_delegate(System.IntPtr obj);
6558      public static Efl.Eo.FunctionWrapper<efl_access_widget_action_elm_actions_get_api_delegate> efl_access_widget_action_elm_actions_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_widget_action_elm_actions_get_api_delegate>(_Module, "efl_access_widget_action_elm_actions_get");
6559      private static Efl.Access.ActionData elm_actions_get(System.IntPtr obj, System.IntPtr pd)
6560     {
6561         Eina.Log.Debug("function efl_access_widget_action_elm_actions_get was called");
6562         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6563         if(wrapper != null) {
6564                         Efl.Access.ActionData _ret_var = default(Efl.Access.ActionData);
6565             try {
6566                 _ret_var = ((Widget)wrapper).GetElmActions();
6567             } catch (Exception e) {
6568                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6569                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6570             }
6571         return _ret_var;
6572         } else {
6573             return efl_access_widget_action_elm_actions_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6574         }
6575     }
6576     private static efl_access_widget_action_elm_actions_get_delegate efl_access_widget_action_elm_actions_get_static_delegate;
6577
6578
6579      private delegate void efl_ui_dnd_drag_start_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionFormat format,   Eina.Slice data,   Efl.Ui.SelectionAction action,  IntPtr icon_func_data, Efl.Dnd.DragIconCreateInternal icon_func, EinaFreeCb icon_func_free_cb,   uint seat);
6580
6581
6582      public delegate void efl_ui_dnd_drag_start_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionFormat format,   Eina.Slice data,   Efl.Ui.SelectionAction action,  IntPtr icon_func_data, Efl.Dnd.DragIconCreateInternal icon_func, EinaFreeCb icon_func_free_cb,   uint seat);
6583      public static Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_start_api_delegate> efl_ui_dnd_drag_start_ptr = new Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_start_api_delegate>(_Module, "efl_ui_dnd_drag_start");
6584      private static void drag_start(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionFormat format,  Eina.Slice data,  Efl.Ui.SelectionAction action, IntPtr icon_func_data, Efl.Dnd.DragIconCreateInternal icon_func, EinaFreeCb icon_func_free_cb,  uint seat)
6585     {
6586         Eina.Log.Debug("function efl_ui_dnd_drag_start was called");
6587         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6588         if(wrapper != null) {
6589                                                                                                                                 Efl.Dnd.DragIconCreateWrapper icon_func_wrapper = new Efl.Dnd.DragIconCreateWrapper(icon_func, icon_func_data, icon_func_free_cb);
6590
6591             try {
6592                 ((Widget)wrapper).DragStart( format,  data,  action,  icon_func_wrapper.ManagedCb,  seat);
6593             } catch (Exception e) {
6594                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6595                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6596             }
6597                                                                                                 } else {
6598             efl_ui_dnd_drag_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  format,  data,  action, icon_func_data, icon_func, icon_func_free_cb,  seat);
6599         }
6600     }
6601     private static efl_ui_dnd_drag_start_delegate efl_ui_dnd_drag_start_static_delegate;
6602
6603
6604      private delegate void efl_ui_dnd_drag_action_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionAction action,   uint seat);
6605
6606
6607      public delegate void efl_ui_dnd_drag_action_set_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionAction action,   uint seat);
6608      public static Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_action_set_api_delegate> efl_ui_dnd_drag_action_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_action_set_api_delegate>(_Module, "efl_ui_dnd_drag_action_set");
6609      private static void drag_action_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionAction action,  uint seat)
6610     {
6611         Eina.Log.Debug("function efl_ui_dnd_drag_action_set was called");
6612         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6613         if(wrapper != null) {
6614
6615             try {
6616                 ((Widget)wrapper).SetDragAction( action,  seat);
6617             } catch (Exception e) {
6618                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6619                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6620             }
6621                                                 } else {
6622             efl_ui_dnd_drag_action_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  action,  seat);
6623         }
6624     }
6625     private static efl_ui_dnd_drag_action_set_delegate efl_ui_dnd_drag_action_set_static_delegate;
6626
6627
6628      private delegate void efl_ui_dnd_drag_cancel_delegate(System.IntPtr obj, System.IntPtr pd,   uint seat);
6629
6630
6631      public delegate void efl_ui_dnd_drag_cancel_api_delegate(System.IntPtr obj,   uint seat);
6632      public static Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_cancel_api_delegate> efl_ui_dnd_drag_cancel_ptr = new Efl.Eo.FunctionWrapper<efl_ui_dnd_drag_cancel_api_delegate>(_Module, "efl_ui_dnd_drag_cancel");
6633      private static void drag_cancel(System.IntPtr obj, System.IntPtr pd,  uint seat)
6634     {
6635         Eina.Log.Debug("function efl_ui_dnd_drag_cancel was called");
6636         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6637         if(wrapper != null) {
6638
6639             try {
6640                 ((Widget)wrapper).DragCancel( seat);
6641             } catch (Exception e) {
6642                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6643                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6644             }
6645                                 } else {
6646             efl_ui_dnd_drag_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  seat);
6647         }
6648     }
6649     private static efl_ui_dnd_drag_cancel_delegate efl_ui_dnd_drag_cancel_static_delegate;
6650
6651
6652      private delegate void efl_ui_dnd_drop_target_add_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionFormat format,   uint seat);
6653
6654
6655      public delegate void efl_ui_dnd_drop_target_add_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionFormat format,   uint seat);
6656      public static Efl.Eo.FunctionWrapper<efl_ui_dnd_drop_target_add_api_delegate> efl_ui_dnd_drop_target_add_ptr = new Efl.Eo.FunctionWrapper<efl_ui_dnd_drop_target_add_api_delegate>(_Module, "efl_ui_dnd_drop_target_add");
6657      private static void drop_target_add(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionFormat format,  uint seat)
6658     {
6659         Eina.Log.Debug("function efl_ui_dnd_drop_target_add was called");
6660         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6661         if(wrapper != null) {
6662
6663             try {
6664                 ((Widget)wrapper).AddDropTarget( format,  seat);
6665             } catch (Exception e) {
6666                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6667                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6668             }
6669                                                 } else {
6670             efl_ui_dnd_drop_target_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  format,  seat);
6671         }
6672     }
6673     private static efl_ui_dnd_drop_target_add_delegate efl_ui_dnd_drop_target_add_static_delegate;
6674
6675
6676      private delegate void efl_ui_dnd_drop_target_del_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionFormat format,   uint seat);
6677
6678
6679      public delegate void efl_ui_dnd_drop_target_del_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionFormat format,   uint seat);
6680      public static Efl.Eo.FunctionWrapper<efl_ui_dnd_drop_target_del_api_delegate> efl_ui_dnd_drop_target_del_ptr = new Efl.Eo.FunctionWrapper<efl_ui_dnd_drop_target_del_api_delegate>(_Module, "efl_ui_dnd_drop_target_del");
6681      private static void drop_target_del(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionFormat format,  uint seat)
6682     {
6683         Eina.Log.Debug("function efl_ui_dnd_drop_target_del was called");
6684         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6685         if(wrapper != null) {
6686
6687             try {
6688                 ((Widget)wrapper).DelDropTarget( format,  seat);
6689             } catch (Exception e) {
6690                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6691                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6692             }
6693                                                 } else {
6694             efl_ui_dnd_drop_target_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  format,  seat);
6695         }
6696     }
6697     private static efl_ui_dnd_drop_target_del_delegate efl_ui_dnd_drop_target_del_static_delegate;
6698
6699
6700      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_l10n_text_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  out System.String domain);
6701
6702
6703      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_l10n_text_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  out System.String domain);
6704      public static Efl.Eo.FunctionWrapper<efl_ui_l10n_text_get_api_delegate> efl_ui_l10n_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_text_get_api_delegate>(_Module, "efl_ui_l10n_text_get");
6705      private static System.String l10n_text_get(System.IntPtr obj, System.IntPtr pd,  out System.String domain)
6706     {
6707         Eina.Log.Debug("function efl_ui_l10n_text_get was called");
6708         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6709         if(wrapper != null) {
6710                             System.String _out_domain = default(System.String);
6711                     System.String _ret_var = default(System.String);
6712             try {
6713                 _ret_var = ((Widget)wrapper).GetL10nText( out _out_domain);
6714             } catch (Exception e) {
6715                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6716                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6717             }
6718         domain = _out_domain;
6719                 return _ret_var;
6720         } else {
6721             return efl_ui_l10n_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out domain);
6722         }
6723     }
6724     private static efl_ui_l10n_text_get_delegate efl_ui_l10n_text_get_static_delegate;
6725
6726
6727      private delegate void efl_ui_l10n_text_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String label,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String domain);
6728
6729
6730      public delegate void efl_ui_l10n_text_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String label,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String domain);
6731      public static Efl.Eo.FunctionWrapper<efl_ui_l10n_text_set_api_delegate> efl_ui_l10n_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_text_set_api_delegate>(_Module, "efl_ui_l10n_text_set");
6732      private static void l10n_text_set(System.IntPtr obj, System.IntPtr pd,  System.String label,  System.String domain)
6733     {
6734         Eina.Log.Debug("function efl_ui_l10n_text_set was called");
6735         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6736         if(wrapper != null) {
6737
6738             try {
6739                 ((Widget)wrapper).SetL10nText( label,  domain);
6740             } catch (Exception e) {
6741                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6742                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6743             }
6744                                                 } else {
6745             efl_ui_l10n_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  label,  domain);
6746         }
6747     }
6748     private static efl_ui_l10n_text_set_delegate efl_ui_l10n_text_set_static_delegate;
6749
6750
6751      private delegate void efl_ui_l10n_translation_update_delegate(System.IntPtr obj, System.IntPtr pd);
6752
6753
6754      public delegate void efl_ui_l10n_translation_update_api_delegate(System.IntPtr obj);
6755      public static Efl.Eo.FunctionWrapper<efl_ui_l10n_translation_update_api_delegate> efl_ui_l10n_translation_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_translation_update_api_delegate>(_Module, "efl_ui_l10n_translation_update");
6756      private static void translation_update(System.IntPtr obj, System.IntPtr pd)
6757     {
6758         Eina.Log.Debug("function efl_ui_l10n_translation_update was called");
6759         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6760         if(wrapper != null) {
6761
6762             try {
6763                 ((Widget)wrapper).UpdateTranslation();
6764             } catch (Exception e) {
6765                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6766                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6767             }
6768                 } else {
6769             efl_ui_l10n_translation_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6770         }
6771     }
6772     private static efl_ui_l10n_translation_update_delegate efl_ui_l10n_translation_update_static_delegate;
6773
6774
6775      private delegate Eina.Error efl_ui_property_bind_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String property);
6776
6777
6778      public delegate Eina.Error efl_ui_property_bind_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String property);
6779      public static Efl.Eo.FunctionWrapper<efl_ui_property_bind_api_delegate> efl_ui_property_bind_ptr = new Efl.Eo.FunctionWrapper<efl_ui_property_bind_api_delegate>(_Module, "efl_ui_property_bind");
6780      private static Eina.Error property_bind(System.IntPtr obj, System.IntPtr pd,  System.String key,  System.String property)
6781     {
6782         Eina.Log.Debug("function efl_ui_property_bind was called");
6783         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6784         if(wrapper != null) {
6785                                                                         Eina.Error _ret_var = default(Eina.Error);
6786             try {
6787                 _ret_var = ((Widget)wrapper).PropertyBind( key,  property);
6788             } catch (Exception e) {
6789                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6790                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6791             }
6792                                         return _ret_var;
6793         } else {
6794             return efl_ui_property_bind_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key,  property);
6795         }
6796     }
6797     private static efl_ui_property_bind_delegate efl_ui_property_bind_static_delegate;
6798
6799
6800     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))] private delegate  Eina.Future efl_ui_selection_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionType type,   Efl.Ui.SelectionFormat format,   Eina.Slice data,   uint seat);
6801
6802
6803     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))] public delegate  Eina.Future efl_ui_selection_set_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionType type,   Efl.Ui.SelectionFormat format,   Eina.Slice data,   uint seat);
6804      public static Efl.Eo.FunctionWrapper<efl_ui_selection_set_api_delegate> efl_ui_selection_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_selection_set_api_delegate>(_Module, "efl_ui_selection_set");
6805      private static  Eina.Future selection_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionType type,  Efl.Ui.SelectionFormat format,  Eina.Slice data,  uint seat)
6806     {
6807         Eina.Log.Debug("function efl_ui_selection_set was called");
6808         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6809         if(wrapper != null) {
6810                                                                                                                          Eina.Future _ret_var = default( Eina.Future);
6811             try {
6812                 _ret_var = ((Widget)wrapper).SetSelection( type,  format,  data,  seat);
6813             } catch (Exception e) {
6814                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6815                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6816             }
6817                                                                         return _ret_var;
6818         } else {
6819             return efl_ui_selection_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  format,  data,  seat);
6820         }
6821     }
6822     private static efl_ui_selection_set_delegate efl_ui_selection_set_static_delegate;
6823
6824
6825      private delegate void efl_ui_selection_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionType type,   Efl.Ui.SelectionFormat format,  IntPtr data_func_data, Efl.Ui.SelectionDataReadyInternal data_func, EinaFreeCb data_func_free_cb,   uint seat);
6826
6827
6828      public delegate void efl_ui_selection_get_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionType type,   Efl.Ui.SelectionFormat format,  IntPtr data_func_data, Efl.Ui.SelectionDataReadyInternal data_func, EinaFreeCb data_func_free_cb,   uint seat);
6829      public static Efl.Eo.FunctionWrapper<efl_ui_selection_get_api_delegate> efl_ui_selection_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_selection_get_api_delegate>(_Module, "efl_ui_selection_get");
6830      private static void selection_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionType type,  Efl.Ui.SelectionFormat format, IntPtr data_func_data, Efl.Ui.SelectionDataReadyInternal data_func, EinaFreeCb data_func_free_cb,  uint seat)
6831     {
6832         Eina.Log.Debug("function efl_ui_selection_get was called");
6833         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6834         if(wrapper != null) {
6835                                                                                                         Efl.Ui.SelectionDataReadyWrapper data_func_wrapper = new Efl.Ui.SelectionDataReadyWrapper(data_func, data_func_data, data_func_free_cb);
6836
6837             try {
6838                 ((Widget)wrapper).GetSelection( type,  format,  data_func_wrapper.ManagedCb,  seat);
6839             } catch (Exception e) {
6840                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6841                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6842             }
6843                                                                                 } else {
6844             efl_ui_selection_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  format, data_func_data, data_func, data_func_free_cb,  seat);
6845         }
6846     }
6847     private static efl_ui_selection_get_delegate efl_ui_selection_get_static_delegate;
6848
6849
6850      private delegate void efl_ui_selection_clear_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionType type,   uint seat);
6851
6852
6853      public delegate void efl_ui_selection_clear_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionType type,   uint seat);
6854      public static Efl.Eo.FunctionWrapper<efl_ui_selection_clear_api_delegate> efl_ui_selection_clear_ptr = new Efl.Eo.FunctionWrapper<efl_ui_selection_clear_api_delegate>(_Module, "efl_ui_selection_clear");
6855      private static void selection_clear(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionType type,  uint seat)
6856     {
6857         Eina.Log.Debug("function efl_ui_selection_clear was called");
6858         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6859         if(wrapper != null) {
6860
6861             try {
6862                 ((Widget)wrapper).ClearSelection( type,  seat);
6863             } catch (Exception e) {
6864                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6865                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6866             }
6867                                                 } else {
6868             efl_ui_selection_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  seat);
6869         }
6870     }
6871     private static efl_ui_selection_clear_delegate efl_ui_selection_clear_static_delegate;
6872
6873
6874      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_selection_has_owner_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectionType type,   uint seat);
6875
6876
6877      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_selection_has_owner_api_delegate(System.IntPtr obj,   Efl.Ui.SelectionType type,   uint seat);
6878      public static Efl.Eo.FunctionWrapper<efl_ui_selection_has_owner_api_delegate> efl_ui_selection_has_owner_ptr = new Efl.Eo.FunctionWrapper<efl_ui_selection_has_owner_api_delegate>(_Module, "efl_ui_selection_has_owner");
6879      private static bool has_owner(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectionType type,  uint seat)
6880     {
6881         Eina.Log.Debug("function efl_ui_selection_has_owner was called");
6882         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6883         if(wrapper != null) {
6884                                                                         bool _ret_var = default(bool);
6885             try {
6886                 _ret_var = ((Widget)wrapper).HasOwner( type,  seat);
6887             } catch (Exception e) {
6888                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6889                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6890             }
6891                                         return _ret_var;
6892         } else {
6893             return efl_ui_selection_has_owner_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  type,  seat);
6894         }
6895     }
6896     private static efl_ui_selection_has_owner_delegate efl_ui_selection_has_owner_static_delegate;
6897
6898
6899     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IModelConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.IModel efl_ui_view_model_get_delegate(System.IntPtr obj, System.IntPtr pd);
6900
6901
6902     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IModelConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.IModel efl_ui_view_model_get_api_delegate(System.IntPtr obj);
6903      public static Efl.Eo.FunctionWrapper<efl_ui_view_model_get_api_delegate> efl_ui_view_model_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_view_model_get_api_delegate>(_Module, "efl_ui_view_model_get");
6904      private static Efl.IModel model_get(System.IntPtr obj, System.IntPtr pd)
6905     {
6906         Eina.Log.Debug("function efl_ui_view_model_get was called");
6907         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6908         if(wrapper != null) {
6909                         Efl.IModel _ret_var = default(Efl.IModel);
6910             try {
6911                 _ret_var = ((Widget)wrapper).GetModel();
6912             } catch (Exception e) {
6913                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6914                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6915             }
6916         return _ret_var;
6917         } else {
6918             return efl_ui_view_model_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6919         }
6920     }
6921     private static efl_ui_view_model_get_delegate efl_ui_view_model_get_static_delegate;
6922
6923
6924      private delegate void efl_ui_view_model_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IModelConcrete, Efl.Eo.NonOwnTag>))]  Efl.IModel model);
6925
6926
6927      public delegate void efl_ui_view_model_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.IModelConcrete, Efl.Eo.NonOwnTag>))]  Efl.IModel model);
6928      public static Efl.Eo.FunctionWrapper<efl_ui_view_model_set_api_delegate> efl_ui_view_model_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_view_model_set_api_delegate>(_Module, "efl_ui_view_model_set");
6929      private static void model_set(System.IntPtr obj, System.IntPtr pd,  Efl.IModel model)
6930     {
6931         Eina.Log.Debug("function efl_ui_view_model_set was called");
6932         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6933         if(wrapper != null) {
6934
6935             try {
6936                 ((Widget)wrapper).SetModel( model);
6937             } catch (Exception e) {
6938                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6939                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6940             }
6941                                 } else {
6942             efl_ui_view_model_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  model);
6943         }
6944     }
6945     private static efl_ui_view_model_set_delegate efl_ui_view_model_set_static_delegate;
6946
6947
6948      private delegate Eina.Rect.NativeStruct efl_ui_focus_object_focus_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
6949
6950
6951      public delegate Eina.Rect.NativeStruct efl_ui_focus_object_focus_geometry_get_api_delegate(System.IntPtr obj);
6952      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_geometry_get_api_delegate> efl_ui_focus_object_focus_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_geometry_get_api_delegate>(_Module, "efl_ui_focus_object_focus_geometry_get");
6953      private static Eina.Rect.NativeStruct focus_geometry_get(System.IntPtr obj, System.IntPtr pd)
6954     {
6955         Eina.Log.Debug("function efl_ui_focus_object_focus_geometry_get was called");
6956         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6957         if(wrapper != null) {
6958                         Eina.Rect _ret_var = default(Eina.Rect);
6959             try {
6960                 _ret_var = ((Widget)wrapper).GetFocusGeometry();
6961             } catch (Exception e) {
6962                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6963                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6964             }
6965         return _ret_var;
6966         } else {
6967             return efl_ui_focus_object_focus_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6968         }
6969     }
6970     private static efl_ui_focus_object_focus_geometry_get_delegate efl_ui_focus_object_focus_geometry_get_static_delegate;
6971
6972
6973      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
6974
6975
6976      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_focus_get_api_delegate(System.IntPtr obj);
6977      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_get_api_delegate> efl_ui_focus_object_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_get_api_delegate>(_Module, "efl_ui_focus_object_focus_get");
6978      private static bool focus_get(System.IntPtr obj, System.IntPtr pd)
6979     {
6980         Eina.Log.Debug("function efl_ui_focus_object_focus_get was called");
6981         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
6982         if(wrapper != null) {
6983                         bool _ret_var = default(bool);
6984             try {
6985                 _ret_var = ((Widget)wrapper).GetFocus();
6986             } catch (Exception e) {
6987                 Eina.Log.Warning($"Callback error: {e.ToString()}");
6988                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6989             }
6990         return _ret_var;
6991         } else {
6992             return efl_ui_focus_object_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6993         }
6994     }
6995     private static efl_ui_focus_object_focus_get_delegate efl_ui_focus_object_focus_get_static_delegate;
6996
6997
6998      private delegate void efl_ui_focus_object_focus_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool focus);
6999
7000
7001      public delegate void efl_ui_focus_object_focus_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool focus);
7002      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_set_api_delegate> efl_ui_focus_object_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_set_api_delegate>(_Module, "efl_ui_focus_object_focus_set");
7003      private static void focus_set(System.IntPtr obj, System.IntPtr pd,  bool focus)
7004     {
7005         Eina.Log.Debug("function efl_ui_focus_object_focus_set was called");
7006         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7007         if(wrapper != null) {
7008
7009             try {
7010                 ((Widget)wrapper).SetFocus( focus);
7011             } catch (Exception e) {
7012                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7013                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7014             }
7015                                 } else {
7016             efl_ui_focus_object_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  focus);
7017         }
7018     }
7019     private static efl_ui_focus_object_focus_set_delegate efl_ui_focus_object_focus_set_static_delegate;
7020
7021
7022     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.IManagerConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Focus.IManager efl_ui_focus_object_focus_manager_get_delegate(System.IntPtr obj, System.IntPtr pd);
7023
7024
7025     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.IManagerConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Focus.IManager efl_ui_focus_object_focus_manager_get_api_delegate(System.IntPtr obj);
7026      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_manager_get_api_delegate> efl_ui_focus_object_focus_manager_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_manager_get_api_delegate>(_Module, "efl_ui_focus_object_focus_manager_get");
7027      private static Efl.Ui.Focus.IManager focus_manager_get(System.IntPtr obj, System.IntPtr pd)
7028     {
7029         Eina.Log.Debug("function efl_ui_focus_object_focus_manager_get was called");
7030         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7031         if(wrapper != null) {
7032                         Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
7033             try {
7034                 _ret_var = ((Widget)wrapper).GetFocusManager();
7035             } catch (Exception e) {
7036                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7037                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7038             }
7039         return _ret_var;
7040         } else {
7041             return efl_ui_focus_object_focus_manager_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7042         }
7043     }
7044     private static efl_ui_focus_object_focus_manager_get_delegate efl_ui_focus_object_focus_manager_get_static_delegate;
7045
7046
7047     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.IObjectConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.Focus.IObject efl_ui_focus_object_focus_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
7048
7049
7050     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.Focus.IObjectConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.Focus.IObject efl_ui_focus_object_focus_parent_get_api_delegate(System.IntPtr obj);
7051      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_parent_get_api_delegate> efl_ui_focus_object_focus_parent_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_focus_parent_get_api_delegate>(_Module, "efl_ui_focus_object_focus_parent_get");
7052      private static Efl.Ui.Focus.IObject focus_parent_get(System.IntPtr obj, System.IntPtr pd)
7053     {
7054         Eina.Log.Debug("function efl_ui_focus_object_focus_parent_get was called");
7055         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7056         if(wrapper != null) {
7057                         Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
7058             try {
7059                 _ret_var = ((Widget)wrapper).GetFocusParent();
7060             } catch (Exception e) {
7061                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7062                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7063             }
7064         return _ret_var;
7065         } else {
7066             return efl_ui_focus_object_focus_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7067         }
7068     }
7069     private static efl_ui_focus_object_focus_parent_get_delegate efl_ui_focus_object_focus_parent_get_static_delegate;
7070
7071
7072      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_child_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
7073
7074
7075      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_child_focus_get_api_delegate(System.IntPtr obj);
7076      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_get_api_delegate> efl_ui_focus_object_child_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_get_api_delegate>(_Module, "efl_ui_focus_object_child_focus_get");
7077      private static bool child_focus_get(System.IntPtr obj, System.IntPtr pd)
7078     {
7079         Eina.Log.Debug("function efl_ui_focus_object_child_focus_get was called");
7080         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7081         if(wrapper != null) {
7082                         bool _ret_var = default(bool);
7083             try {
7084                 _ret_var = ((Widget)wrapper).GetChildFocus();
7085             } catch (Exception e) {
7086                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7087                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7088             }
7089         return _ret_var;
7090         } else {
7091             return efl_ui_focus_object_child_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7092         }
7093     }
7094     private static efl_ui_focus_object_child_focus_get_delegate efl_ui_focus_object_child_focus_get_static_delegate;
7095
7096
7097      private delegate void efl_ui_focus_object_child_focus_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool child_focus);
7098
7099
7100      public delegate void efl_ui_focus_object_child_focus_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool child_focus);
7101      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_set_api_delegate> efl_ui_focus_object_child_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_child_focus_set_api_delegate>(_Module, "efl_ui_focus_object_child_focus_set");
7102      private static void child_focus_set(System.IntPtr obj, System.IntPtr pd,  bool child_focus)
7103     {
7104         Eina.Log.Debug("function efl_ui_focus_object_child_focus_set was called");
7105         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7106         if(wrapper != null) {
7107
7108             try {
7109                 ((Widget)wrapper).SetChildFocus( child_focus);
7110             } catch (Exception e) {
7111                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7112                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7113             }
7114                                 } else {
7115             efl_ui_focus_object_child_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child_focus);
7116         }
7117     }
7118     private static efl_ui_focus_object_child_focus_set_delegate efl_ui_focus_object_child_focus_set_static_delegate;
7119
7120
7121      private delegate void efl_ui_focus_object_setup_order_delegate(System.IntPtr obj, System.IntPtr pd);
7122
7123
7124      public delegate void efl_ui_focus_object_setup_order_api_delegate(System.IntPtr obj);
7125      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_api_delegate> efl_ui_focus_object_setup_order_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_api_delegate>(_Module, "efl_ui_focus_object_setup_order");
7126      private static void setup_order(System.IntPtr obj, System.IntPtr pd)
7127     {
7128         Eina.Log.Debug("function efl_ui_focus_object_setup_order was called");
7129         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7130         if(wrapper != null) {
7131
7132             try {
7133                 ((Widget)wrapper).SetupOrder();
7134             } catch (Exception e) {
7135                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7136                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7137             }
7138                 } else {
7139             efl_ui_focus_object_setup_order_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7140         }
7141     }
7142     private static efl_ui_focus_object_setup_order_delegate efl_ui_focus_object_setup_order_static_delegate;
7143
7144
7145      private delegate void efl_ui_focus_object_setup_order_non_recursive_delegate(System.IntPtr obj, System.IntPtr pd);
7146
7147
7148      public delegate void efl_ui_focus_object_setup_order_non_recursive_api_delegate(System.IntPtr obj);
7149      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_non_recursive_api_delegate> efl_ui_focus_object_setup_order_non_recursive_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_setup_order_non_recursive_api_delegate>(_Module, "efl_ui_focus_object_setup_order_non_recursive");
7150      private static void setup_order_non_recursive(System.IntPtr obj, System.IntPtr pd)
7151     {
7152         Eina.Log.Debug("function efl_ui_focus_object_setup_order_non_recursive was called");
7153         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7154         if(wrapper != null) {
7155
7156             try {
7157                 ((Widget)wrapper).SetupOrderNonRecursive();
7158             } catch (Exception e) {
7159                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7160                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7161             }
7162                 } else {
7163             efl_ui_focus_object_setup_order_non_recursive_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7164         }
7165     }
7166     private static efl_ui_focus_object_setup_order_non_recursive_delegate efl_ui_focus_object_setup_order_non_recursive_static_delegate;
7167
7168
7169      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_object_on_focus_update_delegate(System.IntPtr obj, System.IntPtr pd);
7170
7171
7172      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_object_on_focus_update_api_delegate(System.IntPtr obj);
7173      public static Efl.Eo.FunctionWrapper<efl_ui_focus_object_on_focus_update_api_delegate> efl_ui_focus_object_on_focus_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_object_on_focus_update_api_delegate>(_Module, "efl_ui_focus_object_on_focus_update");
7174      private static bool on_focus_update(System.IntPtr obj, System.IntPtr pd)
7175     {
7176         Eina.Log.Debug("function efl_ui_focus_object_on_focus_update was called");
7177         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
7178         if(wrapper != null) {
7179                         bool _ret_var = default(bool);
7180             try {
7181                 _ret_var = ((Widget)wrapper).UpdateOnFocus();
7182             } catch (Exception e) {
7183                 Eina.Log.Warning($"Callback error: {e.ToString()}");
7184                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
7185             }
7186         return _ret_var;
7187         } else {
7188             return efl_ui_focus_object_on_focus_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
7189         }
7190     }
7191     private static efl_ui_focus_object_on_focus_update_delegate efl_ui_focus_object_on_focus_update_static_delegate;
7192 }
7193 } }
7194 namespace Efl { namespace Ui {
7195 /// <summary>All relevant fields needed for the current state of focus registration
7196 /// (Since EFL 1.22)</summary>
7197 [StructLayout(LayoutKind.Sequential)]
7198 public struct WidgetFocusState
7199 {
7200     /// <summary>The manager where the widget is registered in</summary>
7201     public Efl.Ui.Focus.IManager Manager;
7202     /// <summary>The parent the widget is using as logical parent</summary>
7203     public Efl.Ui.Focus.IObject Parent;
7204     /// <summary><c>true</c> if this is registered as logical currently</summary>
7205     public bool Logical;
7206     ///<summary>Constructor for WidgetFocusState.</summary>
7207     public WidgetFocusState(
7208         Efl.Ui.Focus.IManager Manager=default(Efl.Ui.Focus.IManager),
7209         Efl.Ui.Focus.IObject Parent=default(Efl.Ui.Focus.IObject),
7210         bool Logical=default(bool)    )
7211     {
7212         this.Manager = Manager;
7213         this.Parent = Parent;
7214         this.Logical = Logical;
7215     }
7216
7217     public static implicit operator WidgetFocusState(IntPtr ptr)
7218     {
7219         var tmp = (WidgetFocusState.NativeStruct)Marshal.PtrToStructure(ptr, typeof(WidgetFocusState.NativeStruct));
7220         return tmp;
7221     }
7222
7223     ///<summary>Internal wrapper for struct WidgetFocusState.</summary>
7224     [StructLayout(LayoutKind.Sequential)]
7225     public struct NativeStruct
7226     {
7227         ///<summary>Internal wrapper for field Manager</summary>
7228         public System.IntPtr Manager;
7229         ///<summary>Internal wrapper for field Parent</summary>
7230         public System.IntPtr Parent;
7231         ///<summary>Internal wrapper for field Logical</summary>
7232         public System.Byte Logical;
7233         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
7234         public static implicit operator WidgetFocusState.NativeStruct(WidgetFocusState _external_struct)
7235         {
7236             var _internal_struct = new WidgetFocusState.NativeStruct();
7237             _internal_struct.Manager = _external_struct.Manager?.NativeHandle ?? System.IntPtr.Zero;
7238             _internal_struct.Parent = _external_struct.Parent?.NativeHandle ?? System.IntPtr.Zero;
7239             _internal_struct.Logical = _external_struct.Logical ? (byte)1 : (byte)0;
7240             return _internal_struct;
7241         }
7242
7243         ///<summary>Implicit conversion to the managed representation.</summary>
7244         public static implicit operator WidgetFocusState(WidgetFocusState.NativeStruct _internal_struct)
7245         {
7246             var _external_struct = new WidgetFocusState();
7247
7248             _external_struct.Manager = (Efl.Ui.Focus.IManagerConcrete) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Manager);
7249
7250             _external_struct.Parent = (Efl.Ui.Focus.IObjectConcrete) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Parent);
7251             _external_struct.Logical = _internal_struct.Logical != 0;
7252             return _external_struct;
7253         }
7254
7255     }
7256
7257 }
7258
7259 } }