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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Access {
  11
  12 /// <summary>Accessibility object state set.</summary>
  13 public struct StateSet
  14 {
  15     private ulong payload;
  16
  17     /// <summary>Converts an instance of ulong to this struct.</summary>
  18     /// <param name="value">The value to be converted.</param>
  19     /// <returns>A struct with the given value.</returns>
  20     public static implicit operator StateSet(ulong value)
  21     {
  22         return new StateSet{payload=value};
  23     }
  24
  25     /// <summary>Converts an instance of this struct to ulong.</summary>
  26     /// <param name="value">The value to be converted packed in this struct.</param>
  27     /// <returns>The actual value the alias is wrapping.</returns>
  28     public static implicit operator ulong(StateSet value)
  29     {
  30         return value.payload;
  31     }
  32
  33 }
  34
  35 }
  36
  37 }
  38
  39 namespace Efl {
  40
  41 namespace Access {
  42
  43 /// <summary>Elementary Accessibility relation set type</summary>
  44 public struct RelationSet
  45 {
  46     private Eina.List<Efl.Access.Relation> payload;
  47
  48     /// <summary>Converts an instance of Eina.List<Efl.Access.Relation> to this struct.</summary>
  49     /// <param name="value">The value to be converted.</param>
  50     /// <returns>A struct with the given value.</returns>
  51     public static implicit operator RelationSet(Eina.List<Efl.Access.Relation> value)
  52     {
  53         return new RelationSet{payload=value};
  54     }
  55
  56     /// <summary>Converts an instance of this struct to Eina.List<Efl.Access.Relation>.</summary>
  57     /// <param name="value">The value to be converted packed in this struct.</param>
  58     /// <returns>The actual value the alias is wrapping.</returns>
  59     public static implicit operator Eina.List<Efl.Access.Relation>(RelationSet value)
  60     {
  61         return value.payload;
  62     }
  63
  64 }
  65
  66 }
  67
  68 }
  69
  70 namespace Efl {
  71
  72 namespace Access {
  73
  74 /// <summary>Accessibility accessible mixin</summary>
  75 [Efl.Access.IObjectConcrete.NativeMethods]
  76 [Efl.Eo.BindingEntity]
  77 public interface IObject :
  78     Efl.Eo.IWrapper, IDisposable
  79 {
  80     /// <summary>Gets an localized string describing accessible object role name.</summary>
  81 /// <returns>Localized accessible object role name</returns>
  82 System.String GetLocalizedRoleName();
  83     /// <summary>Accessible name of the object.</summary>
  84 /// <returns>Accessible name</returns>
  85 System.String GetI18nName();
  86     /// <summary>Accessible name of the object.</summary>
  87 /// <param name="i18n_name">Accessible name</param>
  88 void SetI18nName(System.String i18n_name);
  89     /// <summary>Sets name information callback about widget.
  90 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
  91 /// <param name="name_cb">reading information callback</param>
  92 void SetNameCb(Efl.Access.ReadingInfoCb name_cb, System.IntPtr data);
  93     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
  94 /// <returns>Accessible relation set</returns>
  95 Efl.Access.RelationSet GetRelationSet();
  96     /// <summary>The role of the object in accessibility domain.</summary>
  97 /// <returns>Accessible role</returns>
  98 Efl.Access.Role GetRole();
  99     /// <summary>Sets the role of the object in accessibility domain.</summary>
 100 /// <param name="role">Accessible role</param>
 101 void SetRole(Efl.Access.Role role);
 102     /// <summary>Gets object&apos;s accessible parent.</summary>
 103 /// <returns>Accessible parent</returns>
 104 Efl.Access.IObject GetAccessParent();
 105     /// <summary>Gets object&apos;s accessible parent.</summary>
 106 /// <param name="parent">Accessible parent</param>
 107 void SetAccessParent(Efl.Access.IObject parent);
 108     /// <summary>Sets contextual information callback about widget.
 109 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 110 /// <param name="description_cb">The function called to provide the accessible description.</param>
 111 /// <param name="data">The data passed to @c description_cb.</param>
 112 void SetDescriptionCb(Efl.Access.ReadingInfoCb description_cb, System.IntPtr data);
 113     /// <summary>Sets gesture callback to give widget.
 114 /// 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.
 115 ///
 116 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 117 void SetGestureCb(Efl.Access.GestureCb gesture_cb, System.IntPtr data);
 118     /// <summary>Gets object&apos;s accessible children.</summary>
 119 /// <returns>List of widget&apos;s children</returns>
 120 Eina.List<Efl.Access.IObject> GetAccessChildren();
 121     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
 122 /// <returns>Accessible role name</returns>
 123 System.String GetRoleName();
 124     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
 125 /// <returns>List of object attributes, Must be freed by the user</returns>
 126 Eina.List<Efl.Access.Attribute> GetAttributes();
 127     /// <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
 128 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 129 /// <returns>Reading information types</returns>
 130 Efl.Access.ReadingInfoTypeMask GetReadingInfoType();
 131     /// <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
 132 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 133 /// <param name="reading_info">Reading information types</param>
 134 void SetReadingInfoType(Efl.Access.ReadingInfoTypeMask reading_info);
 135     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
 136 /// <returns>Index in children list</returns>
 137 int GetIndexInParent();
 138     /// <summary>Gets contextual information about object.</summary>
 139 /// <returns>Accessible contextual information</returns>
 140 System.String GetDescription();
 141     /// <summary>Sets widget contextual information.</summary>
 142 /// <param name="description">Accessible contextual information</param>
 143 void SetDescription(System.String description);
 144     /// <summary>Gets set describing object accessible states.</summary>
 145 /// <returns>Accessible state set</returns>
 146 Efl.Access.StateSet GetStateSet();
 147     /// <summary>Gets highlightable of given widget.
 148 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 149 /// <returns>If @c true, the object is highlightable.</returns>
 150 bool GetCanHighlight();
 151     /// <summary>Sets highlightable to given widget.
 152 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 153 /// <param name="can_highlight">If @c true, the object is highlightable.</param>
 154 void SetCanHighlight(bool can_highlight);
 155     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
 156 /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
 157 ///
 158 /// 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.
 159 ///
 160 /// 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>
 161 /// <returns>Translation domain</returns>
 162 System.String GetTranslationDomain();
 163     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
 164 /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
 165 ///
 166 /// 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.
 167 ///
 168 /// 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>
 169 /// <param name="domain">Translation domain</param>
 170 void SetTranslationDomain(System.String domain);
 171         /// <summary>Handles gesture on given widget.</summary>
 172 bool GestureDo(Efl.Access.GestureInfo gesture_info);
 173     /// <summary>Add key-value pair identifying object extra attribute
 174 /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 175 /// <param name="key">The string key to give extra information</param>
 176 /// <param name="value">The string value to give extra information</param>
 177 void AppendAttribute(System.String key, System.String value);
 178     /// <summary>delete key-value pair identifying object extra attributes when key is given</summary>
 179 /// <param name="key">The string key to identify the key-value pair</param>
 180 void DelAttribute(System.String key);
 181     /// <summary>Removes all attributes in accessible object.</summary>
 182 void ClearAttributes();
 183                 /// <summary>Defines the relationship between two accessible objects.
 184 /// Adds a unique relationship between source object and relation_object of a given type.
 185 ///
 186 /// Relationships can be queried by Assistive Technology clients to provide customized feedback, improving overall user experience.
 187 ///
 188 /// 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>
 189 /// <param name="type">Relation type</param>
 190 /// <param name="relation_object">Object to relate to</param>
 191 /// <returns><c>true</c> if relationship was successfully appended, <c>false</c> otherwise</returns>
 192 bool AppendRelationship(Efl.Access.RelationType type, Efl.Access.IObject relation_object);
 193     /// <summary>Removes the relationship between two accessible objects.
 194 /// If relation_object is NULL function removes all relations of the given type.</summary>
 195 /// <param name="type">Relation type</param>
 196 /// <param name="relation_object">Object to remove relation from</param>
 197 void RelationshipRemove(Efl.Access.RelationType type, Efl.Access.IObject relation_object);
 198     /// <summary>Removes all relationships in accessible object.</summary>
 199 void ClearRelationships();
 200     /// <summary>Notifies accessibility clients about current state of the accessible object.
 201 /// Function limits information broadcast to clients to types specified by state_types_mask parameter.
 202 ///
 203 /// if recursive parameter is set, function will traverse all accessible children and call state_notify function on them.</summary>
 204 void StateNotify(Efl.Access.StateSet state_types_mask, bool recursive);
 205                                                                                                                                                     /// <summary>Called when property has changed</summary>
 206     event EventHandler<Efl.Access.IObjectPropertyChangedEvt_Args> PropertyChangedEvt;
 207     /// <summary>Called when children have changed</summary>
 208     event EventHandler<Efl.Access.IObjectChildrenChangedEvt_Args> ChildrenChangedEvt;
 209     /// <summary>Called when state has changed</summary>
 210     event EventHandler<Efl.Access.IObjectStateChangedEvt_Args> StateChangedEvt;
 211     /// <summary>Called when boundaries have changed</summary>
 212     event EventHandler<Efl.Access.IObjectBoundsChangedEvt_Args> BoundsChangedEvt;
 213     /// <summary>Called when visibility has changed</summary>
 214     event EventHandler VisibleDataChangedEvt;
 215     /// <summary>Called when active state of descendant has changed</summary>
 216     event EventHandler<Efl.Access.IObjectActiveDescendantChangedEvt_Args> ActiveDescendantChangedEvt;
 217     /// <summary>Called when item is added</summary>
 218     event EventHandler AddedEvt;
 219     /// <summary>Called when item is removed</summary>
 220     event EventHandler RemovedEvt;
 221     event EventHandler MoveOutedEvt;
 222     /// <summary>Gets an localized string describing accessible object role name.</summary>
 223     /// <value>Localized accessible object role name</value>
 224     System.String LocalizedRoleName {
 225         get ;
 226     }
 227     /// <summary>Accessible name of the object.</summary>
 228     /// <value>Accessible name</value>
 229     System.String I18nName {
 230         get ;
 231         set ;
 232     }
 233     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
 234     /// <value>Accessible relation set</value>
 235     Efl.Access.RelationSet RelationSet {
 236         get ;
 237     }
 238     /// <summary>The role of the object in accessibility domain.</summary>
 239     /// <value>Accessible role</value>
 240     Efl.Access.Role Role {
 241         get ;
 242         set ;
 243     }
 244     /// <summary>Gets object&apos;s accessible parent.</summary>
 245     /// <value>Accessible parent</value>
 246     Efl.Access.IObject AccessParent {
 247         get ;
 248         set ;
 249     }
 250     /// <summary>Gets object&apos;s accessible children.</summary>
 251     /// <value>List of widget&apos;s children</value>
 252     Eina.List<Efl.Access.IObject> AccessChildren {
 253         get ;
 254     }
 255     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
 256     /// <value>Accessible role name</value>
 257     System.String RoleName {
 258         get ;
 259     }
 260     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
 261     /// <value>List of object attributes, Must be freed by the user</value>
 262     Eina.List<Efl.Access.Attribute> Attributes {
 263         get ;
 264     }
 265     /// <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
 266     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 267     /// <value>Reading information types</value>
 268     Efl.Access.ReadingInfoTypeMask ReadingInfoType {
 269         get ;
 270         set ;
 271     }
 272     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
 273     /// <value>Index in children list</value>
 274     int IndexInParent {
 275         get ;
 276     }
 277     /// <summary>Gets contextual information about object.</summary>
 278     /// <value>Accessible contextual information</value>
 279     System.String Description {
 280         get ;
 281         set ;
 282     }
 283     /// <summary>Gets set describing object accessible states.</summary>
 284     /// <value>Accessible state set</value>
 285     Efl.Access.StateSet StateSet {
 286         get ;
 287     }
 288     /// <summary>Gets highlightable of given widget.
 289     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 290     /// <value>If @c true, the object is highlightable.</value>
 291     bool CanHighlight {
 292         get ;
 293         set ;
 294     }
 295     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
 296     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
 297     ///
 298     /// 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.
 299     ///
 300     /// 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>
 301     /// <value>Translation domain</value>
 302     System.String TranslationDomain {
 303         get ;
 304         set ;
 305     }
 306 }
 307 ///<summary>Event argument wrapper for event <see cref="Efl.Access.IObject.PropertyChangedEvt"/>.</summary>
 308 [Efl.Eo.BindingEntity]
 309 public class IObjectPropertyChangedEvt_Args : EventArgs {
 310     ///<summary>Actual event payload.</summary>
 311     public System.String arg { get; set; }
 312 }
 313 ///<summary>Event argument wrapper for event <see cref="Efl.Access.IObject.ChildrenChangedEvt"/>.</summary>
 314 [Efl.Eo.BindingEntity]
 315 public class IObjectChildrenChangedEvt_Args : EventArgs {
 316     ///<summary>Actual event payload.</summary>
 317     public Efl.Access.Event.ChildrenChanged.Data arg { get; set; }
 318 }
 319 ///<summary>Event argument wrapper for event <see cref="Efl.Access.IObject.StateChangedEvt"/>.</summary>
 320 [Efl.Eo.BindingEntity]
 321 public class IObjectStateChangedEvt_Args : EventArgs {
 322     ///<summary>Actual event payload.</summary>
 323     public Efl.Access.Event.StateChanged.Data arg { get; set; }
 324 }
 325 ///<summary>Event argument wrapper for event <see cref="Efl.Access.IObject.BoundsChangedEvt"/>.</summary>
 326 [Efl.Eo.BindingEntity]
 327 public class IObjectBoundsChangedEvt_Args : EventArgs {
 328     ///<summary>Actual event payload.</summary>
 329     public Efl.Access.Event.GeometryChanged.Data arg { get; set; }
 330 }
 331 ///<summary>Event argument wrapper for event <see cref="Efl.Access.IObject.ActiveDescendantChangedEvt"/>.</summary>
 332 [Efl.Eo.BindingEntity]
 333 public class IObjectActiveDescendantChangedEvt_Args : EventArgs {
 334     ///<summary>Actual event payload.</summary>
 335     public Efl.Object arg { get; set; }
 336 }
 337 /// <summary>Accessibility accessible mixin</summary>
 338 sealed public class IObjectConcrete :
 339     Efl.Eo.EoWrapper
 340     , IObject
 341
 342 {
 343     ///<summary>Pointer to the native class description.</summary>
 344     public override System.IntPtr NativeClass
 345     {
 346         get
 347         {
 348             if (((object)this).GetType() == typeof(IObjectConcrete))
 349             {
 350                 return GetEflClassStatic();
 351             }
 352             else
 353             {
 354                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 355             }
 356         }
 357     }
 358
 359     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 360     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 361     private IObjectConcrete(ConstructingHandle ch) : base(ch)
 362     {
 363     }
 364
 365     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
 366         efl_access_object_mixin_get();
 367     /// <summary>Initializes a new instance of the <see cref="IObject"/> class.
 368     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 369     /// <param name="wh">The native pointer to be wrapped.</param>
 370     private IObjectConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 371     {
 372     }
 373
 374     /// <summary>Called when property has changed</summary>
 375     public event EventHandler<Efl.Access.IObjectPropertyChangedEvt_Args> PropertyChangedEvt
 376     {
 377         add
 378         {
 379             lock (eflBindingEventLock)
 380             {
 381                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 382                 {
 383                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 384                     if (obj != null)
 385                     {
 386                         Efl.Access.IObjectPropertyChangedEvt_Args args = new Efl.Access.IObjectPropertyChangedEvt_Args();
 387                         args.arg = Eina.StringConversion.NativeUtf8ToManagedString(evt.Info);
 388                         try
 389                         {
 390                             value?.Invoke(obj, args);
 391                         }
 392                         catch (Exception e)
 393                         {
 394                             Eina.Log.Error(e.ToString());
 395                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 396                         }
 397                     }
 398                 };
 399
 400                 string key = "_EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED";
 401                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 402             }
 403         }
 404
 405         remove
 406         {
 407             lock (eflBindingEventLock)
 408             {
 409                 string key = "_EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED";
 410                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 411             }
 412         }
 413     }
 414     ///<summary>Method to raise event PropertyChangedEvt.</summary>
 415     public void OnPropertyChangedEvt(Efl.Access.IObjectPropertyChangedEvt_Args e)
 416     {
 417         var key = "_EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED";
 418         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 419         if (desc == IntPtr.Zero)
 420         {
 421             Eina.Log.Error($"Failed to get native event {key}");
 422             return;
 423         }
 424
 425         IntPtr info = Eina.StringConversion.ManagedStringToNativeUtf8Alloc(e.arg);
 426         try
 427         {
 428             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 429         }
 430         finally
 431         {
 432             Eina.MemoryNative.Free(info);
 433         }
 434     }
 435     /// <summary>Called when children have changed</summary>
 436     public event EventHandler<Efl.Access.IObjectChildrenChangedEvt_Args> ChildrenChangedEvt
 437     {
 438         add
 439         {
 440             lock (eflBindingEventLock)
 441             {
 442                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 443                 {
 444                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 445                     if (obj != null)
 446                     {
 447                         Efl.Access.IObjectChildrenChangedEvt_Args args = new Efl.Access.IObjectChildrenChangedEvt_Args();
 448                         args.arg =  evt.Info;
 449                         try
 450                         {
 451                             value?.Invoke(obj, args);
 452                         }
 453                         catch (Exception e)
 454                         {
 455                             Eina.Log.Error(e.ToString());
 456                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 457                         }
 458                     }
 459                 };
 460
 461                 string key = "_EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED";
 462                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 463             }
 464         }
 465
 466         remove
 467         {
 468             lock (eflBindingEventLock)
 469             {
 470                 string key = "_EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED";
 471                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 472             }
 473         }
 474     }
 475     ///<summary>Method to raise event ChildrenChangedEvt.</summary>
 476     public void OnChildrenChangedEvt(Efl.Access.IObjectChildrenChangedEvt_Args e)
 477     {
 478         var key = "_EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED";
 479         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 480         if (desc == IntPtr.Zero)
 481         {
 482             Eina.Log.Error($"Failed to get native event {key}");
 483             return;
 484         }
 485
 486         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 487         try
 488         {
 489             Marshal.StructureToPtr(e.arg, info, false);
 490             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 491         }
 492         finally
 493         {
 494             Marshal.FreeHGlobal(info);
 495         }
 496     }
 497     /// <summary>Called when state has changed</summary>
 498     public event EventHandler<Efl.Access.IObjectStateChangedEvt_Args> StateChangedEvt
 499     {
 500         add
 501         {
 502             lock (eflBindingEventLock)
 503             {
 504                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 505                 {
 506                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 507                     if (obj != null)
 508                     {
 509                         Efl.Access.IObjectStateChangedEvt_Args args = new Efl.Access.IObjectStateChangedEvt_Args();
 510                         args.arg =  evt.Info;
 511                         try
 512                         {
 513                             value?.Invoke(obj, args);
 514                         }
 515                         catch (Exception e)
 516                         {
 517                             Eina.Log.Error(e.ToString());
 518                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 519                         }
 520                     }
 521                 };
 522
 523                 string key = "_EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED";
 524                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 525             }
 526         }
 527
 528         remove
 529         {
 530             lock (eflBindingEventLock)
 531             {
 532                 string key = "_EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED";
 533                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 534             }
 535         }
 536     }
 537     ///<summary>Method to raise event StateChangedEvt.</summary>
 538     public void OnStateChangedEvt(Efl.Access.IObjectStateChangedEvt_Args e)
 539     {
 540         var key = "_EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED";
 541         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 542         if (desc == IntPtr.Zero)
 543         {
 544             Eina.Log.Error($"Failed to get native event {key}");
 545             return;
 546         }
 547
 548         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 549         try
 550         {
 551             Marshal.StructureToPtr(e.arg, info, false);
 552             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 553         }
 554         finally
 555         {
 556             Marshal.FreeHGlobal(info);
 557         }
 558     }
 559     /// <summary>Called when boundaries have changed</summary>
 560     public event EventHandler<Efl.Access.IObjectBoundsChangedEvt_Args> BoundsChangedEvt
 561     {
 562         add
 563         {
 564             lock (eflBindingEventLock)
 565             {
 566                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 567                 {
 568                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 569                     if (obj != null)
 570                     {
 571                         Efl.Access.IObjectBoundsChangedEvt_Args args = new Efl.Access.IObjectBoundsChangedEvt_Args();
 572                         args.arg =  evt.Info;
 573                         try
 574                         {
 575                             value?.Invoke(obj, args);
 576                         }
 577                         catch (Exception e)
 578                         {
 579                             Eina.Log.Error(e.ToString());
 580                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 581                         }
 582                     }
 583                 };
 584
 585                 string key = "_EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED";
 586                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 587             }
 588         }
 589
 590         remove
 591         {
 592             lock (eflBindingEventLock)
 593             {
 594                 string key = "_EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED";
 595                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 596             }
 597         }
 598     }
 599     ///<summary>Method to raise event BoundsChangedEvt.</summary>
 600     public void OnBoundsChangedEvt(Efl.Access.IObjectBoundsChangedEvt_Args e)
 601     {
 602         var key = "_EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED";
 603         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 604         if (desc == IntPtr.Zero)
 605         {
 606             Eina.Log.Error($"Failed to get native event {key}");
 607             return;
 608         }
 609
 610         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 611         try
 612         {
 613             Marshal.StructureToPtr(e.arg, info, false);
 614             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 615         }
 616         finally
 617         {
 618             Marshal.FreeHGlobal(info);
 619         }
 620     }
 621     /// <summary>Called when visibility has changed</summary>
 622     public event EventHandler VisibleDataChangedEvt
 623     {
 624         add
 625         {
 626             lock (eflBindingEventLock)
 627             {
 628                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 629                 {
 630                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 631                     if (obj != null)
 632                     {
 633                         EventArgs args = EventArgs.Empty;
 634                         try
 635                         {
 636                             value?.Invoke(obj, args);
 637                         }
 638                         catch (Exception e)
 639                         {
 640                             Eina.Log.Error(e.ToString());
 641                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 642                         }
 643                     }
 644                 };
 645
 646                 string key = "_EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED";
 647                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 648             }
 649         }
 650
 651         remove
 652         {
 653             lock (eflBindingEventLock)
 654             {
 655                 string key = "_EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED";
 656                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 657             }
 658         }
 659     }
 660     ///<summary>Method to raise event VisibleDataChangedEvt.</summary>
 661     public void OnVisibleDataChangedEvt(EventArgs e)
 662     {
 663         var key = "_EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED";
 664         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 665         if (desc == IntPtr.Zero)
 666         {
 667             Eina.Log.Error($"Failed to get native event {key}");
 668             return;
 669         }
 670
 671         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 672     }
 673     /// <summary>Called when active state of descendant has changed</summary>
 674     public event EventHandler<Efl.Access.IObjectActiveDescendantChangedEvt_Args> ActiveDescendantChangedEvt
 675     {
 676         add
 677         {
 678             lock (eflBindingEventLock)
 679             {
 680                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 681                 {
 682                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 683                     if (obj != null)
 684                     {
 685                         Efl.Access.IObjectActiveDescendantChangedEvt_Args args = new Efl.Access.IObjectActiveDescendantChangedEvt_Args();
 686                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 687                         try
 688                         {
 689                             value?.Invoke(obj, args);
 690                         }
 691                         catch (Exception e)
 692                         {
 693                             Eina.Log.Error(e.ToString());
 694                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 695                         }
 696                     }
 697                 };
 698
 699                 string key = "_EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED";
 700                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 701             }
 702         }
 703
 704         remove
 705         {
 706             lock (eflBindingEventLock)
 707             {
 708                 string key = "_EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED";
 709                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 710             }
 711         }
 712     }
 713     ///<summary>Method to raise event ActiveDescendantChangedEvt.</summary>
 714     public void OnActiveDescendantChangedEvt(Efl.Access.IObjectActiveDescendantChangedEvt_Args e)
 715     {
 716         var key = "_EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED";
 717         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 718         if (desc == IntPtr.Zero)
 719         {
 720             Eina.Log.Error($"Failed to get native event {key}");
 721             return;
 722         }
 723
 724         IntPtr info = e.arg.NativeHandle;
 725         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 726     }
 727     /// <summary>Called when item is added</summary>
 728     public event EventHandler AddedEvt
 729     {
 730         add
 731         {
 732             lock (eflBindingEventLock)
 733             {
 734                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 735                 {
 736                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 737                     if (obj != null)
 738                     {
 739                         EventArgs args = EventArgs.Empty;
 740                         try
 741                         {
 742                             value?.Invoke(obj, args);
 743                         }
 744                         catch (Exception e)
 745                         {
 746                             Eina.Log.Error(e.ToString());
 747                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 748                         }
 749                     }
 750                 };
 751
 752                 string key = "_EFL_ACCESS_OBJECT_EVENT_ADDED";
 753                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 754             }
 755         }
 756
 757         remove
 758         {
 759             lock (eflBindingEventLock)
 760             {
 761                 string key = "_EFL_ACCESS_OBJECT_EVENT_ADDED";
 762                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 763             }
 764         }
 765     }
 766     ///<summary>Method to raise event AddedEvt.</summary>
 767     public void OnAddedEvt(EventArgs e)
 768     {
 769         var key = "_EFL_ACCESS_OBJECT_EVENT_ADDED";
 770         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 771         if (desc == IntPtr.Zero)
 772         {
 773             Eina.Log.Error($"Failed to get native event {key}");
 774             return;
 775         }
 776
 777         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 778     }
 779     /// <summary>Called when item is removed</summary>
 780     public event EventHandler RemovedEvt
 781     {
 782         add
 783         {
 784             lock (eflBindingEventLock)
 785             {
 786                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 787                 {
 788                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 789                     if (obj != null)
 790                     {
 791                         EventArgs args = EventArgs.Empty;
 792                         try
 793                         {
 794                             value?.Invoke(obj, args);
 795                         }
 796                         catch (Exception e)
 797                         {
 798                             Eina.Log.Error(e.ToString());
 799                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 800                         }
 801                     }
 802                 };
 803
 804                 string key = "_EFL_ACCESS_OBJECT_EVENT_REMOVED";
 805                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 806             }
 807         }
 808
 809         remove
 810         {
 811             lock (eflBindingEventLock)
 812             {
 813                 string key = "_EFL_ACCESS_OBJECT_EVENT_REMOVED";
 814                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 815             }
 816         }
 817     }
 818     ///<summary>Method to raise event RemovedEvt.</summary>
 819     public void OnRemovedEvt(EventArgs e)
 820     {
 821         var key = "_EFL_ACCESS_OBJECT_EVENT_REMOVED";
 822         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 823         if (desc == IntPtr.Zero)
 824         {
 825             Eina.Log.Error($"Failed to get native event {key}");
 826             return;
 827         }
 828
 829         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 830     }
 831     public event EventHandler MoveOutedEvt
 832     {
 833         add
 834         {
 835             lock (eflBindingEventLock)
 836             {
 837                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 838                 {
 839                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 840                     if (obj != null)
 841                     {
 842                         EventArgs args = EventArgs.Empty;
 843                         try
 844                         {
 845                             value?.Invoke(obj, args);
 846                         }
 847                         catch (Exception e)
 848                         {
 849                             Eina.Log.Error(e.ToString());
 850                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 851                         }
 852                     }
 853                 };
 854
 855                 string key = "_EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED";
 856                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 857             }
 858         }
 859
 860         remove
 861         {
 862             lock (eflBindingEventLock)
 863             {
 864                 string key = "_EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED";
 865                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 866             }
 867         }
 868     }
 869     ///<summary>Method to raise event MoveOutedEvt.</summary>
 870     public void OnMoveOutedEvt(EventArgs e)
 871     {
 872         var key = "_EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED";
 873         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 874         if (desc == IntPtr.Zero)
 875         {
 876             Eina.Log.Error($"Failed to get native event {key}");
 877             return;
 878         }
 879
 880         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 881     }
 882     /// <summary>Gets an localized string describing accessible object role name.</summary>
 883     /// <returns>Localized accessible object role name</returns>
 884     public System.String GetLocalizedRoleName() {
 885          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_localized_role_name_get_ptr.Value.Delegate(this.NativeHandle);
 886         Eina.Error.RaiseIfUnhandledException();
 887         return _ret_var;
 888  }
 889     /// <summary>Accessible name of the object.</summary>
 890     /// <returns>Accessible name</returns>
 891     public System.String GetI18nName() {
 892          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_i18n_name_get_ptr.Value.Delegate(this.NativeHandle);
 893         Eina.Error.RaiseIfUnhandledException();
 894         return _ret_var;
 895  }
 896     /// <summary>Accessible name of the object.</summary>
 897     /// <param name="i18n_name">Accessible name</param>
 898     public void SetI18nName(System.String i18n_name) {
 899                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_i18n_name_set_ptr.Value.Delegate(this.NativeHandle,i18n_name);
 900         Eina.Error.RaiseIfUnhandledException();
 901                          }
 902     /// <summary>Sets name information callback about widget.
 903     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 904     /// <param name="name_cb">reading information callback</param>
 905     public void SetNameCb(Efl.Access.ReadingInfoCb name_cb, System.IntPtr data) {
 906                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_name_cb_set_ptr.Value.Delegate(this.NativeHandle,name_cb, data);
 907         Eina.Error.RaiseIfUnhandledException();
 908                                          }
 909     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
 910     /// <returns>Accessible relation set</returns>
 911     public Efl.Access.RelationSet GetRelationSet() {
 912          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_relation_set_get_ptr.Value.Delegate(this.NativeHandle);
 913         Eina.Error.RaiseIfUnhandledException();
 914         return _ret_var;
 915  }
 916     /// <summary>The role of the object in accessibility domain.</summary>
 917     /// <returns>Accessible role</returns>
 918     public Efl.Access.Role GetRole() {
 919          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_role_get_ptr.Value.Delegate(this.NativeHandle);
 920         Eina.Error.RaiseIfUnhandledException();
 921         return _ret_var;
 922  }
 923     /// <summary>Sets the role of the object in accessibility domain.</summary>
 924     /// <param name="role">Accessible role</param>
 925     public void SetRole(Efl.Access.Role role) {
 926                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_role_set_ptr.Value.Delegate(this.NativeHandle,role);
 927         Eina.Error.RaiseIfUnhandledException();
 928                          }
 929     /// <summary>Gets object&apos;s accessible parent.</summary>
 930     /// <returns>Accessible parent</returns>
 931     public Efl.Access.IObject GetAccessParent() {
 932          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_access_parent_get_ptr.Value.Delegate(this.NativeHandle);
 933         Eina.Error.RaiseIfUnhandledException();
 934         return _ret_var;
 935  }
 936     /// <summary>Gets object&apos;s accessible parent.</summary>
 937     /// <param name="parent">Accessible parent</param>
 938     public void SetAccessParent(Efl.Access.IObject parent) {
 939                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_access_parent_set_ptr.Value.Delegate(this.NativeHandle,parent);
 940         Eina.Error.RaiseIfUnhandledException();
 941                          }
 942     /// <summary>Sets contextual information callback about widget.
 943     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 944     /// <param name="description_cb">The function called to provide the accessible description.</param>
 945     /// <param name="data">The data passed to @c description_cb.</param>
 946     public void SetDescriptionCb(Efl.Access.ReadingInfoCb description_cb, System.IntPtr data) {
 947                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_description_cb_set_ptr.Value.Delegate(this.NativeHandle,description_cb, data);
 948         Eina.Error.RaiseIfUnhandledException();
 949                                          }
 950     /// <summary>Sets gesture callback to give widget.
 951     /// 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.
 952     ///
 953     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 954     public void SetGestureCb(Efl.Access.GestureCb gesture_cb, System.IntPtr data) {
 955                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_gesture_cb_set_ptr.Value.Delegate(this.NativeHandle,gesture_cb, data);
 956         Eina.Error.RaiseIfUnhandledException();
 957                                          }
 958     /// <summary>Gets object&apos;s accessible children.</summary>
 959     /// <returns>List of widget&apos;s children</returns>
 960     public Eina.List<Efl.Access.IObject> GetAccessChildren() {
 961          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_access_children_get_ptr.Value.Delegate(this.NativeHandle);
 962         Eina.Error.RaiseIfUnhandledException();
 963         return new Eina.List<Efl.Access.IObject>(_ret_var, true, false);
 964  }
 965     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
 966     /// <returns>Accessible role name</returns>
 967     public System.String GetRoleName() {
 968          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_role_name_get_ptr.Value.Delegate(this.NativeHandle);
 969         Eina.Error.RaiseIfUnhandledException();
 970         return _ret_var;
 971  }
 972     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
 973     /// <returns>List of object attributes, Must be freed by the user</returns>
 974     public Eina.List<Efl.Access.Attribute> GetAttributes() {
 975          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_attributes_get_ptr.Value.Delegate(this.NativeHandle);
 976         Eina.Error.RaiseIfUnhandledException();
 977         return new Eina.List<Efl.Access.Attribute>(_ret_var, true, true);
 978  }
 979     /// <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
 980     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 981     /// <returns>Reading information types</returns>
 982     public Efl.Access.ReadingInfoTypeMask GetReadingInfoType() {
 983          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_reading_info_type_get_ptr.Value.Delegate(this.NativeHandle);
 984         Eina.Error.RaiseIfUnhandledException();
 985         return _ret_var;
 986  }
 987     /// <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
 988     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
 989     /// <param name="reading_info">Reading information types</param>
 990     public void SetReadingInfoType(Efl.Access.ReadingInfoTypeMask reading_info) {
 991                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_reading_info_type_set_ptr.Value.Delegate(this.NativeHandle,reading_info);
 992         Eina.Error.RaiseIfUnhandledException();
 993                          }
 994     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
 995     /// <returns>Index in children list</returns>
 996     public int GetIndexInParent() {
 997          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_index_in_parent_get_ptr.Value.Delegate(this.NativeHandle);
 998         Eina.Error.RaiseIfUnhandledException();
 999         return _ret_var;
1000  }
1001     /// <summary>Gets contextual information about object.</summary>
1002     /// <returns>Accessible contextual information</returns>
1003     public System.String GetDescription() {
1004          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_description_get_ptr.Value.Delegate(this.NativeHandle);
1005         Eina.Error.RaiseIfUnhandledException();
1006         return _ret_var;
1007  }
1008     /// <summary>Sets widget contextual information.</summary>
1009     /// <param name="description">Accessible contextual information</param>
1010     public void SetDescription(System.String description) {
1011                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_description_set_ptr.Value.Delegate(this.NativeHandle,description);
1012         Eina.Error.RaiseIfUnhandledException();
1013                          }
1014     /// <summary>Gets set describing object accessible states.</summary>
1015     /// <returns>Accessible state set</returns>
1016     public Efl.Access.StateSet GetStateSet() {
1017          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_state_set_get_ptr.Value.Delegate(this.NativeHandle);
1018         Eina.Error.RaiseIfUnhandledException();
1019         return _ret_var;
1020  }
1021     /// <summary>Gets highlightable of given widget.
1022     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
1023     /// <returns>If @c true, the object is highlightable.</returns>
1024     public bool GetCanHighlight() {
1025          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_can_highlight_get_ptr.Value.Delegate(this.NativeHandle);
1026         Eina.Error.RaiseIfUnhandledException();
1027         return _ret_var;
1028  }
1029     /// <summary>Sets highlightable to given widget.
1030     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
1031     /// <param name="can_highlight">If @c true, the object is highlightable.</param>
1032     public void SetCanHighlight(bool can_highlight) {
1033                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_can_highlight_set_ptr.Value.Delegate(this.NativeHandle,can_highlight);
1034         Eina.Error.RaiseIfUnhandledException();
1035                          }
1036     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
1037     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
1038     ///
1039     /// 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.
1040     ///
1041     /// 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>
1042     /// <returns>Translation domain</returns>
1043     public System.String GetTranslationDomain() {
1044          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_translation_domain_get_ptr.Value.Delegate(this.NativeHandle);
1045         Eina.Error.RaiseIfUnhandledException();
1046         return _ret_var;
1047  }
1048     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
1049     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
1050     ///
1051     /// 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.
1052     ///
1053     /// 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>
1054     /// <param name="domain">Translation domain</param>
1055     public void SetTranslationDomain(System.String domain) {
1056                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_translation_domain_set_ptr.Value.Delegate(this.NativeHandle,domain);
1057         Eina.Error.RaiseIfUnhandledException();
1058                          }
1059     /// <summary>Get root object of accessible object hierarchy</summary>
1060     /// <returns>Root object</returns>
1061     public static Efl.Object GetAccessRoot() {
1062          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_access_root_get_ptr.Value.Delegate();
1063         Eina.Error.RaiseIfUnhandledException();
1064         return _ret_var;
1065  }
1066     /// <summary>Handles gesture on given widget.</summary>
1067     public bool GestureDo(Efl.Access.GestureInfo gesture_info) {
1068          Efl.Access.GestureInfo.NativeStruct _in_gesture_info = gesture_info;
1069                         var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_gesture_do_ptr.Value.Delegate(this.NativeHandle,_in_gesture_info);
1070         Eina.Error.RaiseIfUnhandledException();
1071                         return _ret_var;
1072  }
1073     /// <summary>Add key-value pair identifying object extra attribute
1074     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
1075     /// <param name="key">The string key to give extra information</param>
1076     /// <param name="value">The string value to give extra information</param>
1077     public void AppendAttribute(System.String key, System.String value) {
1078                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_attribute_append_ptr.Value.Delegate(this.NativeHandle,key, value);
1079         Eina.Error.RaiseIfUnhandledException();
1080                                          }
1081     /// <summary>delete key-value pair identifying object extra attributes when key is given</summary>
1082     /// <param name="key">The string key to identify the key-value pair</param>
1083     public void DelAttribute(System.String key) {
1084                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_attribute_del_ptr.Value.Delegate(this.NativeHandle,key);
1085         Eina.Error.RaiseIfUnhandledException();
1086                          }
1087     /// <summary>Removes all attributes in accessible object.</summary>
1088     public void ClearAttributes() {
1089          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_attributes_clear_ptr.Value.Delegate(this.NativeHandle);
1090         Eina.Error.RaiseIfUnhandledException();
1091          }
1092     /// <summary>Register accessibility event listener</summary>
1093     /// <param name="cb">Callback</param>
1094     /// <param name="data">Data</param>
1095     /// <returns>Event handler</returns>
1096     public static Efl.Access.Event.Handler AddEventHandler(Efl.EventCb cb, System.IntPtr data) {
1097                                                          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_event_handler_add_ptr.Value.Delegate(cb, data);
1098         Eina.Error.RaiseIfUnhandledException();
1099                                         return _ret_var;
1100  }
1101     /// <summary>Deregister accessibility event listener</summary>
1102     /// <param name="handler">Event handler</param>
1103     public static void DelEventHandler(Efl.Access.Event.Handler handler) {
1104                                  Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_event_handler_del_ptr.Value.Delegate(handler);
1105         Eina.Error.RaiseIfUnhandledException();
1106                          }
1107     /// <summary>Emit event</summary>
1108     /// <param name="accessible">Accessibility object.</param>
1109     /// <param name="kw_event">Accessibility event type.</param>
1110     /// <param name="event_info">Accessibility event details.</param>
1111     public static void EmitEvent(Efl.Access.IObject accessible, Efl.EventDescription kw_event, System.IntPtr event_info) {
1112                  var _in_kw_event = Eina.PrimitiveConversion.ManagedToPointerAlloc(kw_event);
1113                                                                 Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_event_emit_ptr.Value.Delegate(accessible, _in_kw_event, event_info);
1114         Eina.Error.RaiseIfUnhandledException();
1115                                                          }
1116     /// <summary>Defines the relationship between two accessible objects.
1117     /// Adds a unique relationship between source object and relation_object of a given type.
1118     ///
1119     /// Relationships can be queried by Assistive Technology clients to provide customized feedback, improving overall user experience.
1120     ///
1121     /// 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>
1122     /// <param name="type">Relation type</param>
1123     /// <param name="relation_object">Object to relate to</param>
1124     /// <returns><c>true</c> if relationship was successfully appended, <c>false</c> otherwise</returns>
1125     public bool AppendRelationship(Efl.Access.RelationType type, Efl.Access.IObject relation_object) {
1126                                                          var _ret_var = Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_relationship_append_ptr.Value.Delegate(this.NativeHandle,type, relation_object);
1127         Eina.Error.RaiseIfUnhandledException();
1128                                         return _ret_var;
1129  }
1130     /// <summary>Removes the relationship between two accessible objects.
1131     /// If relation_object is NULL function removes all relations of the given type.</summary>
1132     /// <param name="type">Relation type</param>
1133     /// <param name="relation_object">Object to remove relation from</param>
1134     public void RelationshipRemove(Efl.Access.RelationType type, Efl.Access.IObject relation_object) {
1135                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_relationship_remove_ptr.Value.Delegate(this.NativeHandle,type, relation_object);
1136         Eina.Error.RaiseIfUnhandledException();
1137                                          }
1138     /// <summary>Removes all relationships in accessible object.</summary>
1139     public void ClearRelationships() {
1140          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_relationships_clear_ptr.Value.Delegate(this.NativeHandle);
1141         Eina.Error.RaiseIfUnhandledException();
1142          }
1143     /// <summary>Notifies accessibility clients about current state of the accessible object.
1144     /// Function limits information broadcast to clients to types specified by state_types_mask parameter.
1145     ///
1146     /// if recursive parameter is set, function will traverse all accessible children and call state_notify function on them.</summary>
1147     public void StateNotify(Efl.Access.StateSet state_types_mask, bool recursive) {
1148                                                          Efl.Access.IObjectConcrete.NativeMethods.efl_access_object_state_notify_ptr.Value.Delegate(this.NativeHandle,state_types_mask, recursive);
1149         Eina.Error.RaiseIfUnhandledException();
1150                                          }
1151     /// <summary>Gets an localized string describing accessible object role name.</summary>
1152     /// <value>Localized accessible object role name</value>
1153     public System.String LocalizedRoleName {
1154         get { return GetLocalizedRoleName(); }
1155     }
1156     /// <summary>Accessible name of the object.</summary>
1157     /// <value>Accessible name</value>
1158     public System.String I18nName {
1159         get { return GetI18nName(); }
1160         set { SetI18nName(value); }
1161     }
1162     /// <summary>Gets an all relations between accessible object and other accessible objects.</summary>
1163     /// <value>Accessible relation set</value>
1164     public Efl.Access.RelationSet RelationSet {
1165         get { return GetRelationSet(); }
1166     }
1167     /// <summary>The role of the object in accessibility domain.</summary>
1168     /// <value>Accessible role</value>
1169     public Efl.Access.Role Role {
1170         get { return GetRole(); }
1171         set { SetRole(value); }
1172     }
1173     /// <summary>Gets object&apos;s accessible parent.</summary>
1174     /// <value>Accessible parent</value>
1175     public Efl.Access.IObject AccessParent {
1176         get { return GetAccessParent(); }
1177         set { SetAccessParent(value); }
1178     }
1179     /// <summary>Gets object&apos;s accessible children.</summary>
1180     /// <value>List of widget&apos;s children</value>
1181     public Eina.List<Efl.Access.IObject> AccessChildren {
1182         get { return GetAccessChildren(); }
1183     }
1184     /// <summary>Gets human-readable string indentifying object accessibility role.</summary>
1185     /// <value>Accessible role name</value>
1186     public System.String RoleName {
1187         get { return GetRoleName(); }
1188     }
1189     /// <summary>Gets key-value pairs indentifying object extra attributes. Must be free by a user.</summary>
1190     /// <value>List of object attributes, Must be freed by the user</value>
1191     public Eina.List<Efl.Access.Attribute> Attributes {
1192         get { return GetAttributes(); }
1193     }
1194     /// <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
1195     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
1196     /// <value>Reading information types</value>
1197     public Efl.Access.ReadingInfoTypeMask ReadingInfoType {
1198         get { return GetReadingInfoType(); }
1199         set { SetReadingInfoType(value); }
1200     }
1201     /// <summary>Gets index of the child in parent&apos;s children list.</summary>
1202     /// <value>Index in children list</value>
1203     public int IndexInParent {
1204         get { return GetIndexInParent(); }
1205     }
1206     /// <summary>Gets contextual information about object.</summary>
1207     /// <value>Accessible contextual information</value>
1208     public System.String Description {
1209         get { return GetDescription(); }
1210         set { SetDescription(value); }
1211     }
1212     /// <summary>Gets set describing object accessible states.</summary>
1213     /// <value>Accessible state set</value>
1214     public Efl.Access.StateSet StateSet {
1215         get { return GetStateSet(); }
1216     }
1217     /// <summary>Gets highlightable of given widget.
1218     /// @if WEARABLE @since_tizen 3.0 @endif</summary>
1219     /// <value>If @c true, the object is highlightable.</value>
1220     public bool CanHighlight {
1221         get { return GetCanHighlight(); }
1222         set { SetCanHighlight(value); }
1223     }
1224     /// <summary>The translation domain of &quot;name&quot; and &quot;description&quot; properties.
1225     /// Translation domain should be set if the application wants to support i18n for accessibility &quot;name&quot; and &quot;description&quot; properties.
1226     ///
1227     /// 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.
1228     ///
1229     /// 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>
1230     /// <value>Translation domain</value>
1231     public System.String TranslationDomain {
1232         get { return GetTranslationDomain(); }
1233         set { SetTranslationDomain(value); }
1234     }
1235     /// <summary>Get root object of accessible object hierarchy</summary>
1236     /// <value>Root object</value>
1237     public static Efl.Object AccessRoot {
1238         get { return GetAccessRoot(); }
1239     }
1240     private static IntPtr GetEflClassStatic()
1241     {
1242         return Efl.Access.IObjectConcrete.efl_access_object_mixin_get();
1243     }
1244     /// <summary>Wrapper for native methods and virtual method delegates.
1245     /// For internal use by generated code only.</summary>
1246     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
1247     {
1248         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
1249         /// <summary>Gets the list of Eo operations to override.</summary>
1250         /// <returns>The list of Eo operations to be overload.</returns>
1251         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1252         {
1253             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1254             var methods = Efl.Eo.Globals.GetUserMethods(type);
1255
1256             if (efl_access_object_localized_role_name_get_static_delegate == null)
1257             {
1258                 efl_access_object_localized_role_name_get_static_delegate = new efl_access_object_localized_role_name_get_delegate(localized_role_name_get);
1259             }
1260
1261             if (methods.FirstOrDefault(m => m.Name == "GetLocalizedRoleName") != null)
1262             {
1263                 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) });
1264             }
1265
1266             if (efl_access_object_i18n_name_get_static_delegate == null)
1267             {
1268                 efl_access_object_i18n_name_get_static_delegate = new efl_access_object_i18n_name_get_delegate(i18n_name_get);
1269             }
1270
1271             if (methods.FirstOrDefault(m => m.Name == "GetI18nName") != null)
1272             {
1273                 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) });
1274             }
1275
1276             if (efl_access_object_i18n_name_set_static_delegate == null)
1277             {
1278                 efl_access_object_i18n_name_set_static_delegate = new efl_access_object_i18n_name_set_delegate(i18n_name_set);
1279             }
1280
1281             if (methods.FirstOrDefault(m => m.Name == "SetI18nName") != null)
1282             {
1283                 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) });
1284             }
1285
1286             if (efl_access_object_name_cb_set_static_delegate == null)
1287             {
1288                 efl_access_object_name_cb_set_static_delegate = new efl_access_object_name_cb_set_delegate(name_cb_set);
1289             }
1290
1291             if (methods.FirstOrDefault(m => m.Name == "SetNameCb") != null)
1292             {
1293                 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) });
1294             }
1295
1296             if (efl_access_object_relation_set_get_static_delegate == null)
1297             {
1298                 efl_access_object_relation_set_get_static_delegate = new efl_access_object_relation_set_get_delegate(relation_set_get);
1299             }
1300
1301             if (methods.FirstOrDefault(m => m.Name == "GetRelationSet") != null)
1302             {
1303                 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) });
1304             }
1305
1306             if (efl_access_object_role_get_static_delegate == null)
1307             {
1308                 efl_access_object_role_get_static_delegate = new efl_access_object_role_get_delegate(role_get);
1309             }
1310
1311             if (methods.FirstOrDefault(m => m.Name == "GetRole") != null)
1312             {
1313                 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) });
1314             }
1315
1316             if (efl_access_object_role_set_static_delegate == null)
1317             {
1318                 efl_access_object_role_set_static_delegate = new efl_access_object_role_set_delegate(role_set);
1319             }
1320
1321             if (methods.FirstOrDefault(m => m.Name == "SetRole") != null)
1322             {
1323                 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) });
1324             }
1325
1326             if (efl_access_object_access_parent_get_static_delegate == null)
1327             {
1328                 efl_access_object_access_parent_get_static_delegate = new efl_access_object_access_parent_get_delegate(access_parent_get);
1329             }
1330
1331             if (methods.FirstOrDefault(m => m.Name == "GetAccessParent") != null)
1332             {
1333                 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) });
1334             }
1335
1336             if (efl_access_object_access_parent_set_static_delegate == null)
1337             {
1338                 efl_access_object_access_parent_set_static_delegate = new efl_access_object_access_parent_set_delegate(access_parent_set);
1339             }
1340
1341             if (methods.FirstOrDefault(m => m.Name == "SetAccessParent") != null)
1342             {
1343                 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) });
1344             }
1345
1346             if (efl_access_object_description_cb_set_static_delegate == null)
1347             {
1348                 efl_access_object_description_cb_set_static_delegate = new efl_access_object_description_cb_set_delegate(description_cb_set);
1349             }
1350
1351             if (methods.FirstOrDefault(m => m.Name == "SetDescriptionCb") != null)
1352             {
1353                 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) });
1354             }
1355
1356             if (efl_access_object_gesture_cb_set_static_delegate == null)
1357             {
1358                 efl_access_object_gesture_cb_set_static_delegate = new efl_access_object_gesture_cb_set_delegate(gesture_cb_set);
1359             }
1360
1361             if (methods.FirstOrDefault(m => m.Name == "SetGestureCb") != null)
1362             {
1363                 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) });
1364             }
1365
1366             if (efl_access_object_access_children_get_static_delegate == null)
1367             {
1368                 efl_access_object_access_children_get_static_delegate = new efl_access_object_access_children_get_delegate(access_children_get);
1369             }
1370
1371             if (methods.FirstOrDefault(m => m.Name == "GetAccessChildren") != null)
1372             {
1373                 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) });
1374             }
1375
1376             if (efl_access_object_role_name_get_static_delegate == null)
1377             {
1378                 efl_access_object_role_name_get_static_delegate = new efl_access_object_role_name_get_delegate(role_name_get);
1379             }
1380
1381             if (methods.FirstOrDefault(m => m.Name == "GetRoleName") != null)
1382             {
1383                 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) });
1384             }
1385
1386             if (efl_access_object_attributes_get_static_delegate == null)
1387             {
1388                 efl_access_object_attributes_get_static_delegate = new efl_access_object_attributes_get_delegate(attributes_get);
1389             }
1390
1391             if (methods.FirstOrDefault(m => m.Name == "GetAttributes") != null)
1392             {
1393                 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) });
1394             }
1395
1396             if (efl_access_object_reading_info_type_get_static_delegate == null)
1397             {
1398                 efl_access_object_reading_info_type_get_static_delegate = new efl_access_object_reading_info_type_get_delegate(reading_info_type_get);
1399             }
1400
1401             if (methods.FirstOrDefault(m => m.Name == "GetReadingInfoType") != null)
1402             {
1403                 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) });
1404             }
1405
1406             if (efl_access_object_reading_info_type_set_static_delegate == null)
1407             {
1408                 efl_access_object_reading_info_type_set_static_delegate = new efl_access_object_reading_info_type_set_delegate(reading_info_type_set);
1409             }
1410
1411             if (methods.FirstOrDefault(m => m.Name == "SetReadingInfoType") != null)
1412             {
1413                 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) });
1414             }
1415
1416             if (efl_access_object_index_in_parent_get_static_delegate == null)
1417             {
1418                 efl_access_object_index_in_parent_get_static_delegate = new efl_access_object_index_in_parent_get_delegate(index_in_parent_get);
1419             }
1420
1421             if (methods.FirstOrDefault(m => m.Name == "GetIndexInParent") != null)
1422             {
1423                 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) });
1424             }
1425
1426             if (efl_access_object_description_get_static_delegate == null)
1427             {
1428                 efl_access_object_description_get_static_delegate = new efl_access_object_description_get_delegate(description_get);
1429             }
1430
1431             if (methods.FirstOrDefault(m => m.Name == "GetDescription") != null)
1432             {
1433                 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) });
1434             }
1435
1436             if (efl_access_object_description_set_static_delegate == null)
1437             {
1438                 efl_access_object_description_set_static_delegate = new efl_access_object_description_set_delegate(description_set);
1439             }
1440
1441             if (methods.FirstOrDefault(m => m.Name == "SetDescription") != null)
1442             {
1443                 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) });
1444             }
1445
1446             if (efl_access_object_state_set_get_static_delegate == null)
1447             {
1448                 efl_access_object_state_set_get_static_delegate = new efl_access_object_state_set_get_delegate(state_set_get);
1449             }
1450
1451             if (methods.FirstOrDefault(m => m.Name == "GetStateSet") != null)
1452             {
1453                 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) });
1454             }
1455
1456             if (efl_access_object_can_highlight_get_static_delegate == null)
1457             {
1458                 efl_access_object_can_highlight_get_static_delegate = new efl_access_object_can_highlight_get_delegate(can_highlight_get);
1459             }
1460
1461             if (methods.FirstOrDefault(m => m.Name == "GetCanHighlight") != null)
1462             {
1463                 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) });
1464             }
1465
1466             if (efl_access_object_can_highlight_set_static_delegate == null)
1467             {
1468                 efl_access_object_can_highlight_set_static_delegate = new efl_access_object_can_highlight_set_delegate(can_highlight_set);
1469             }
1470
1471             if (methods.FirstOrDefault(m => m.Name == "SetCanHighlight") != null)
1472             {
1473                 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) });
1474             }
1475
1476             if (efl_access_object_translation_domain_get_static_delegate == null)
1477             {
1478                 efl_access_object_translation_domain_get_static_delegate = new efl_access_object_translation_domain_get_delegate(translation_domain_get);
1479             }
1480
1481             if (methods.FirstOrDefault(m => m.Name == "GetTranslationDomain") != null)
1482             {
1483                 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) });
1484             }
1485
1486             if (efl_access_object_translation_domain_set_static_delegate == null)
1487             {
1488                 efl_access_object_translation_domain_set_static_delegate = new efl_access_object_translation_domain_set_delegate(translation_domain_set);
1489             }
1490
1491             if (methods.FirstOrDefault(m => m.Name == "SetTranslationDomain") != null)
1492             {
1493                 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) });
1494             }
1495
1496             if (efl_access_object_gesture_do_static_delegate == null)
1497             {
1498                 efl_access_object_gesture_do_static_delegate = new efl_access_object_gesture_do_delegate(gesture_do);
1499             }
1500
1501             if (methods.FirstOrDefault(m => m.Name == "GestureDo") != null)
1502             {
1503                 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) });
1504             }
1505
1506             if (efl_access_object_attribute_append_static_delegate == null)
1507             {
1508                 efl_access_object_attribute_append_static_delegate = new efl_access_object_attribute_append_delegate(attribute_append);
1509             }
1510
1511             if (methods.FirstOrDefault(m => m.Name == "AppendAttribute") != null)
1512             {
1513                 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) });
1514             }
1515
1516             if (efl_access_object_attribute_del_static_delegate == null)
1517             {
1518                 efl_access_object_attribute_del_static_delegate = new efl_access_object_attribute_del_delegate(attribute_del);
1519             }
1520
1521             if (methods.FirstOrDefault(m => m.Name == "DelAttribute") != null)
1522             {
1523                 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) });
1524             }
1525
1526             if (efl_access_object_attributes_clear_static_delegate == null)
1527             {
1528                 efl_access_object_attributes_clear_static_delegate = new efl_access_object_attributes_clear_delegate(attributes_clear);
1529             }
1530
1531             if (methods.FirstOrDefault(m => m.Name == "ClearAttributes") != null)
1532             {
1533                 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) });
1534             }
1535
1536             if (efl_access_object_relationship_append_static_delegate == null)
1537             {
1538                 efl_access_object_relationship_append_static_delegate = new efl_access_object_relationship_append_delegate(relationship_append);
1539             }
1540
1541             if (methods.FirstOrDefault(m => m.Name == "AppendRelationship") != null)
1542             {
1543                 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) });
1544             }
1545
1546             if (efl_access_object_relationship_remove_static_delegate == null)
1547             {
1548                 efl_access_object_relationship_remove_static_delegate = new efl_access_object_relationship_remove_delegate(relationship_remove);
1549             }
1550
1551             if (methods.FirstOrDefault(m => m.Name == "RelationshipRemove") != null)
1552             {
1553                 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) });
1554             }
1555
1556             if (efl_access_object_relationships_clear_static_delegate == null)
1557             {
1558                 efl_access_object_relationships_clear_static_delegate = new efl_access_object_relationships_clear_delegate(relationships_clear);
1559             }
1560
1561             if (methods.FirstOrDefault(m => m.Name == "ClearRelationships") != null)
1562             {
1563                 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) });
1564             }
1565
1566             if (efl_access_object_state_notify_static_delegate == null)
1567             {
1568                 efl_access_object_state_notify_static_delegate = new efl_access_object_state_notify_delegate(state_notify);
1569             }
1570
1571             if (methods.FirstOrDefault(m => m.Name == "StateNotify") != null)
1572             {
1573                 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) });
1574             }
1575
1576             return descs;
1577         }
1578         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1579         /// <returns>The native class pointer.</returns>
1580         public override IntPtr GetEflClass()
1581         {
1582             return Efl.Access.IObjectConcrete.efl_access_object_mixin_get();
1583         }
1584
1585         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1586
1587         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1588         private delegate System.String efl_access_object_localized_role_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
1589
1590         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1591         public delegate System.String efl_access_object_localized_role_name_get_api_delegate(System.IntPtr obj);
1592
1593         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");
1594
1595         private static System.String localized_role_name_get(System.IntPtr obj, System.IntPtr pd)
1596         {
1597             Eina.Log.Debug("function efl_access_object_localized_role_name_get was called");
1598             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1599             if (ws != null)
1600             {
1601             System.String _ret_var = default(System.String);
1602                 try
1603                 {
1604                     _ret_var = ((IObject)ws.Target).GetLocalizedRoleName();
1605                 }
1606                 catch (Exception e)
1607                 {
1608                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1609                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1610                 }
1611
1612         return _ret_var;
1613
1614             }
1615             else
1616             {
1617                 return efl_access_object_localized_role_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1618             }
1619         }
1620
1621         private static efl_access_object_localized_role_name_get_delegate efl_access_object_localized_role_name_get_static_delegate;
1622
1623         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1624         private delegate System.String efl_access_object_i18n_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
1625
1626         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1627         public delegate System.String efl_access_object_i18n_name_get_api_delegate(System.IntPtr obj);
1628
1629         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");
1630
1631         private static System.String i18n_name_get(System.IntPtr obj, System.IntPtr pd)
1632         {
1633             Eina.Log.Debug("function efl_access_object_i18n_name_get was called");
1634             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1635             if (ws != null)
1636             {
1637             System.String _ret_var = default(System.String);
1638                 try
1639                 {
1640                     _ret_var = ((IObject)ws.Target).GetI18nName();
1641                 }
1642                 catch (Exception e)
1643                 {
1644                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1645                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1646                 }
1647
1648         return _ret_var;
1649
1650             }
1651             else
1652             {
1653                 return efl_access_object_i18n_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1654             }
1655         }
1656
1657         private static efl_access_object_i18n_name_get_delegate efl_access_object_i18n_name_get_static_delegate;
1658
1659
1660         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);
1661
1662
1663         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);
1664
1665         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");
1666
1667         private static void i18n_name_set(System.IntPtr obj, System.IntPtr pd, System.String i18n_name)
1668         {
1669             Eina.Log.Debug("function efl_access_object_i18n_name_set was called");
1670             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1671             if (ws != null)
1672             {
1673
1674                 try
1675                 {
1676                     ((IObject)ws.Target).SetI18nName(i18n_name);
1677                 }
1678                 catch (Exception e)
1679                 {
1680                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1681                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1682                 }
1683
1684
1685             }
1686             else
1687             {
1688                 efl_access_object_i18n_name_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), i18n_name);
1689             }
1690         }
1691
1692         private static efl_access_object_i18n_name_set_delegate efl_access_object_i18n_name_set_static_delegate;
1693
1694
1695         private delegate void efl_access_object_name_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoCb name_cb,  System.IntPtr data);
1696
1697
1698         public delegate void efl_access_object_name_cb_set_api_delegate(System.IntPtr obj,  Efl.Access.ReadingInfoCb name_cb,  System.IntPtr data);
1699
1700         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");
1701
1702         private static void name_cb_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.ReadingInfoCb name_cb, System.IntPtr data)
1703         {
1704             Eina.Log.Debug("function efl_access_object_name_cb_set was called");
1705             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1706             if (ws != null)
1707             {
1708
1709                 try
1710                 {
1711                     ((IObject)ws.Target).SetNameCb(name_cb, data);
1712                 }
1713                 catch (Exception e)
1714                 {
1715                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1716                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1717                 }
1718
1719
1720             }
1721             else
1722             {
1723                 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);
1724             }
1725         }
1726
1727         private static efl_access_object_name_cb_set_delegate efl_access_object_name_cb_set_static_delegate;
1728
1729
1730         private delegate Efl.Access.RelationSet efl_access_object_relation_set_get_delegate(System.IntPtr obj, System.IntPtr pd);
1731
1732
1733         public delegate Efl.Access.RelationSet efl_access_object_relation_set_get_api_delegate(System.IntPtr obj);
1734
1735         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");
1736
1737         private static Efl.Access.RelationSet relation_set_get(System.IntPtr obj, System.IntPtr pd)
1738         {
1739             Eina.Log.Debug("function efl_access_object_relation_set_get was called");
1740             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1741             if (ws != null)
1742             {
1743             Efl.Access.RelationSet _ret_var = default(Efl.Access.RelationSet);
1744                 try
1745                 {
1746                     _ret_var = ((IObject)ws.Target).GetRelationSet();
1747                 }
1748                 catch (Exception e)
1749                 {
1750                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1751                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1752                 }
1753
1754         return _ret_var;
1755
1756             }
1757             else
1758             {
1759                 return efl_access_object_relation_set_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1760             }
1761         }
1762
1763         private static efl_access_object_relation_set_get_delegate efl_access_object_relation_set_get_static_delegate;
1764
1765
1766         private delegate Efl.Access.Role efl_access_object_role_get_delegate(System.IntPtr obj, System.IntPtr pd);
1767
1768
1769         public delegate Efl.Access.Role efl_access_object_role_get_api_delegate(System.IntPtr obj);
1770
1771         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");
1772
1773         private static Efl.Access.Role role_get(System.IntPtr obj, System.IntPtr pd)
1774         {
1775             Eina.Log.Debug("function efl_access_object_role_get was called");
1776             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1777             if (ws != null)
1778             {
1779             Efl.Access.Role _ret_var = default(Efl.Access.Role);
1780                 try
1781                 {
1782                     _ret_var = ((IObject)ws.Target).GetRole();
1783                 }
1784                 catch (Exception e)
1785                 {
1786                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1787                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1788                 }
1789
1790         return _ret_var;
1791
1792             }
1793             else
1794             {
1795                 return efl_access_object_role_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1796             }
1797         }
1798
1799         private static efl_access_object_role_get_delegate efl_access_object_role_get_static_delegate;
1800
1801
1802         private delegate void efl_access_object_role_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.Role role);
1803
1804
1805         public delegate void efl_access_object_role_set_api_delegate(System.IntPtr obj,  Efl.Access.Role role);
1806
1807         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");
1808
1809         private static void role_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.Role role)
1810         {
1811             Eina.Log.Debug("function efl_access_object_role_set was called");
1812             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1813             if (ws != null)
1814             {
1815
1816                 try
1817                 {
1818                     ((IObject)ws.Target).SetRole(role);
1819                 }
1820                 catch (Exception e)
1821                 {
1822                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1823                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1824                 }
1825
1826
1827             }
1828             else
1829             {
1830                 efl_access_object_role_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), role);
1831             }
1832         }
1833
1834         private static efl_access_object_role_set_delegate efl_access_object_role_set_static_delegate;
1835
1836         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1837         private delegate Efl.Access.IObject efl_access_object_access_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
1838
1839         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1840         public delegate Efl.Access.IObject efl_access_object_access_parent_get_api_delegate(System.IntPtr obj);
1841
1842         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");
1843
1844         private static Efl.Access.IObject access_parent_get(System.IntPtr obj, System.IntPtr pd)
1845         {
1846             Eina.Log.Debug("function efl_access_object_access_parent_get was called");
1847             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1848             if (ws != null)
1849             {
1850             Efl.Access.IObject _ret_var = default(Efl.Access.IObject);
1851                 try
1852                 {
1853                     _ret_var = ((IObject)ws.Target).GetAccessParent();
1854                 }
1855                 catch (Exception e)
1856                 {
1857                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1858                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1859                 }
1860
1861         return _ret_var;
1862
1863             }
1864             else
1865             {
1866                 return efl_access_object_access_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1867             }
1868         }
1869
1870         private static efl_access_object_access_parent_get_delegate efl_access_object_access_parent_get_static_delegate;
1871
1872
1873         private delegate void efl_access_object_access_parent_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject parent);
1874
1875
1876         public delegate void efl_access_object_access_parent_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject parent);
1877
1878         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");
1879
1880         private static void access_parent_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.IObject parent)
1881         {
1882             Eina.Log.Debug("function efl_access_object_access_parent_set was called");
1883             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1884             if (ws != null)
1885             {
1886
1887                 try
1888                 {
1889                     ((IObject)ws.Target).SetAccessParent(parent);
1890                 }
1891                 catch (Exception e)
1892                 {
1893                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1894                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1895                 }
1896
1897
1898             }
1899             else
1900             {
1901                 efl_access_object_access_parent_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), parent);
1902             }
1903         }
1904
1905         private static efl_access_object_access_parent_set_delegate efl_access_object_access_parent_set_static_delegate;
1906
1907
1908         private delegate void efl_access_object_description_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoCb description_cb,  System.IntPtr data);
1909
1910
1911         public delegate void efl_access_object_description_cb_set_api_delegate(System.IntPtr obj,  Efl.Access.ReadingInfoCb description_cb,  System.IntPtr data);
1912
1913         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");
1914
1915         private static void description_cb_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.ReadingInfoCb description_cb, System.IntPtr data)
1916         {
1917             Eina.Log.Debug("function efl_access_object_description_cb_set was called");
1918             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1919             if (ws != null)
1920             {
1921
1922                 try
1923                 {
1924                     ((IObject)ws.Target).SetDescriptionCb(description_cb, data);
1925                 }
1926                 catch (Exception e)
1927                 {
1928                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1929                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1930                 }
1931
1932
1933             }
1934             else
1935             {
1936                 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);
1937             }
1938         }
1939
1940         private static efl_access_object_description_cb_set_delegate efl_access_object_description_cb_set_static_delegate;
1941
1942
1943         private delegate void efl_access_object_gesture_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.GestureCb gesture_cb,  System.IntPtr data);
1944
1945
1946         public delegate void efl_access_object_gesture_cb_set_api_delegate(System.IntPtr obj,  Efl.Access.GestureCb gesture_cb,  System.IntPtr data);
1947
1948         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");
1949
1950         private static void gesture_cb_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.GestureCb gesture_cb, System.IntPtr data)
1951         {
1952             Eina.Log.Debug("function efl_access_object_gesture_cb_set was called");
1953             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1954             if (ws != null)
1955             {
1956
1957                 try
1958                 {
1959                     ((IObject)ws.Target).SetGestureCb(gesture_cb, data);
1960                 }
1961                 catch (Exception e)
1962                 {
1963                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1964                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1965                 }
1966
1967
1968             }
1969             else
1970             {
1971                 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);
1972             }
1973         }
1974
1975         private static efl_access_object_gesture_cb_set_delegate efl_access_object_gesture_cb_set_static_delegate;
1976
1977
1978         private delegate System.IntPtr efl_access_object_access_children_get_delegate(System.IntPtr obj, System.IntPtr pd);
1979
1980
1981         public delegate System.IntPtr efl_access_object_access_children_get_api_delegate(System.IntPtr obj);
1982
1983         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");
1984
1985         private static System.IntPtr access_children_get(System.IntPtr obj, System.IntPtr pd)
1986         {
1987             Eina.Log.Debug("function efl_access_object_access_children_get was called");
1988             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1989             if (ws != null)
1990             {
1991             Eina.List<Efl.Access.IObject> _ret_var = default(Eina.List<Efl.Access.IObject>);
1992                 try
1993                 {
1994                     _ret_var = ((IObject)ws.Target).GetAccessChildren();
1995                 }
1996                 catch (Exception e)
1997                 {
1998                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1999                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2000                 }
2001
2002         _ret_var.Own = false; return _ret_var.Handle;
2003
2004             }
2005             else
2006             {
2007                 return efl_access_object_access_children_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2008             }
2009         }
2010
2011         private static efl_access_object_access_children_get_delegate efl_access_object_access_children_get_static_delegate;
2012
2013         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2014         private delegate System.String efl_access_object_role_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
2015
2016         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2017         public delegate System.String efl_access_object_role_name_get_api_delegate(System.IntPtr obj);
2018
2019         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");
2020
2021         private static System.String role_name_get(System.IntPtr obj, System.IntPtr pd)
2022         {
2023             Eina.Log.Debug("function efl_access_object_role_name_get was called");
2024             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2025             if (ws != null)
2026             {
2027             System.String _ret_var = default(System.String);
2028                 try
2029                 {
2030                     _ret_var = ((IObject)ws.Target).GetRoleName();
2031                 }
2032                 catch (Exception e)
2033                 {
2034                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2035                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2036                 }
2037
2038         return _ret_var;
2039
2040             }
2041             else
2042             {
2043                 return efl_access_object_role_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2044             }
2045         }
2046
2047         private static efl_access_object_role_name_get_delegate efl_access_object_role_name_get_static_delegate;
2048
2049
2050         private delegate System.IntPtr efl_access_object_attributes_get_delegate(System.IntPtr obj, System.IntPtr pd);
2051
2052
2053         public delegate System.IntPtr efl_access_object_attributes_get_api_delegate(System.IntPtr obj);
2054
2055         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");
2056
2057         private static System.IntPtr attributes_get(System.IntPtr obj, System.IntPtr pd)
2058         {
2059             Eina.Log.Debug("function efl_access_object_attributes_get was called");
2060             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2061             if (ws != null)
2062             {
2063             Eina.List<Efl.Access.Attribute> _ret_var = default(Eina.List<Efl.Access.Attribute>);
2064                 try
2065                 {
2066                     _ret_var = ((IObject)ws.Target).GetAttributes();
2067                 }
2068                 catch (Exception e)
2069                 {
2070                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2071                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2072                 }
2073
2074         _ret_var.Own = false; _ret_var.OwnContent = false; return _ret_var.Handle;
2075
2076             }
2077             else
2078             {
2079                 return efl_access_object_attributes_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2080             }
2081         }
2082
2083         private static efl_access_object_attributes_get_delegate efl_access_object_attributes_get_static_delegate;
2084
2085
2086         private delegate Efl.Access.ReadingInfoTypeMask efl_access_object_reading_info_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
2087
2088
2089         public delegate Efl.Access.ReadingInfoTypeMask efl_access_object_reading_info_type_get_api_delegate(System.IntPtr obj);
2090
2091         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");
2092
2093         private static Efl.Access.ReadingInfoTypeMask reading_info_type_get(System.IntPtr obj, System.IntPtr pd)
2094         {
2095             Eina.Log.Debug("function efl_access_object_reading_info_type_get was called");
2096             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2097             if (ws != null)
2098             {
2099             Efl.Access.ReadingInfoTypeMask _ret_var = default(Efl.Access.ReadingInfoTypeMask);
2100                 try
2101                 {
2102                     _ret_var = ((IObject)ws.Target).GetReadingInfoType();
2103                 }
2104                 catch (Exception e)
2105                 {
2106                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2107                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2108                 }
2109
2110         return _ret_var;
2111
2112             }
2113             else
2114             {
2115                 return efl_access_object_reading_info_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2116             }
2117         }
2118
2119         private static efl_access_object_reading_info_type_get_delegate efl_access_object_reading_info_type_get_static_delegate;
2120
2121
2122         private delegate void efl_access_object_reading_info_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.ReadingInfoTypeMask reading_info);
2123
2124
2125         public delegate void efl_access_object_reading_info_type_set_api_delegate(System.IntPtr obj,  Efl.Access.ReadingInfoTypeMask reading_info);
2126
2127         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");
2128
2129         private static void reading_info_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Access.ReadingInfoTypeMask reading_info)
2130         {
2131             Eina.Log.Debug("function efl_access_object_reading_info_type_set was called");
2132             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2133             if (ws != null)
2134             {
2135
2136                 try
2137                 {
2138                     ((IObject)ws.Target).SetReadingInfoType(reading_info);
2139                 }
2140                 catch (Exception e)
2141                 {
2142                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2143                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2144                 }
2145
2146
2147             }
2148             else
2149             {
2150                 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);
2151             }
2152         }
2153
2154         private static efl_access_object_reading_info_type_set_delegate efl_access_object_reading_info_type_set_static_delegate;
2155
2156
2157         private delegate int efl_access_object_index_in_parent_get_delegate(System.IntPtr obj, System.IntPtr pd);
2158
2159
2160         public delegate int efl_access_object_index_in_parent_get_api_delegate(System.IntPtr obj);
2161
2162         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");
2163
2164         private static int index_in_parent_get(System.IntPtr obj, System.IntPtr pd)
2165         {
2166             Eina.Log.Debug("function efl_access_object_index_in_parent_get was called");
2167             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2168             if (ws != null)
2169             {
2170             int _ret_var = default(int);
2171                 try
2172                 {
2173                     _ret_var = ((IObject)ws.Target).GetIndexInParent();
2174                 }
2175                 catch (Exception e)
2176                 {
2177                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2178                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2179                 }
2180
2181         return _ret_var;
2182
2183             }
2184             else
2185             {
2186                 return efl_access_object_index_in_parent_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2187             }
2188         }
2189
2190         private static efl_access_object_index_in_parent_get_delegate efl_access_object_index_in_parent_get_static_delegate;
2191
2192         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2193         private delegate System.String efl_access_object_description_get_delegate(System.IntPtr obj, System.IntPtr pd);
2194
2195         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2196         public delegate System.String efl_access_object_description_get_api_delegate(System.IntPtr obj);
2197
2198         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");
2199
2200         private static System.String description_get(System.IntPtr obj, System.IntPtr pd)
2201         {
2202             Eina.Log.Debug("function efl_access_object_description_get was called");
2203             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2204             if (ws != null)
2205             {
2206             System.String _ret_var = default(System.String);
2207                 try
2208                 {
2209                     _ret_var = ((IObject)ws.Target).GetDescription();
2210                 }
2211                 catch (Exception e)
2212                 {
2213                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2214                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2215                 }
2216
2217         return _ret_var;
2218
2219             }
2220             else
2221             {
2222                 return efl_access_object_description_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2223             }
2224         }
2225
2226         private static efl_access_object_description_get_delegate efl_access_object_description_get_static_delegate;
2227
2228
2229         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);
2230
2231
2232         public delegate void efl_access_object_description_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String description);
2233
2234         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");
2235
2236         private static void description_set(System.IntPtr obj, System.IntPtr pd, System.String description)
2237         {
2238             Eina.Log.Debug("function efl_access_object_description_set was called");
2239             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2240             if (ws != null)
2241             {
2242
2243                 try
2244                 {
2245                     ((IObject)ws.Target).SetDescription(description);
2246                 }
2247                 catch (Exception e)
2248                 {
2249                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2250                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2251                 }
2252
2253
2254             }
2255             else
2256             {
2257                 efl_access_object_description_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), description);
2258             }
2259         }
2260
2261         private static efl_access_object_description_set_delegate efl_access_object_description_set_static_delegate;
2262
2263
2264         private delegate Efl.Access.StateSet efl_access_object_state_set_get_delegate(System.IntPtr obj, System.IntPtr pd);
2265
2266
2267         public delegate Efl.Access.StateSet efl_access_object_state_set_get_api_delegate(System.IntPtr obj);
2268
2269         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");
2270
2271         private static Efl.Access.StateSet state_set_get(System.IntPtr obj, System.IntPtr pd)
2272         {
2273             Eina.Log.Debug("function efl_access_object_state_set_get was called");
2274             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2275             if (ws != null)
2276             {
2277             Efl.Access.StateSet _ret_var = default(Efl.Access.StateSet);
2278                 try
2279                 {
2280                     _ret_var = ((IObject)ws.Target).GetStateSet();
2281                 }
2282                 catch (Exception e)
2283                 {
2284                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2285                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2286                 }
2287
2288         return _ret_var;
2289
2290             }
2291             else
2292             {
2293                 return efl_access_object_state_set_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2294             }
2295         }
2296
2297         private static efl_access_object_state_set_get_delegate efl_access_object_state_set_get_static_delegate;
2298
2299         [return: MarshalAs(UnmanagedType.U1)]
2300         private delegate bool efl_access_object_can_highlight_get_delegate(System.IntPtr obj, System.IntPtr pd);
2301
2302         [return: MarshalAs(UnmanagedType.U1)]
2303         public delegate bool efl_access_object_can_highlight_get_api_delegate(System.IntPtr obj);
2304
2305         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");
2306
2307         private static bool can_highlight_get(System.IntPtr obj, System.IntPtr pd)
2308         {
2309             Eina.Log.Debug("function efl_access_object_can_highlight_get was called");
2310             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2311             if (ws != null)
2312             {
2313             bool _ret_var = default(bool);
2314                 try
2315                 {
2316                     _ret_var = ((IObject)ws.Target).GetCanHighlight();
2317                 }
2318                 catch (Exception e)
2319                 {
2320                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2321                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2322                 }
2323
2324         return _ret_var;
2325
2326             }
2327             else
2328             {
2329                 return efl_access_object_can_highlight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2330             }
2331         }
2332
2333         private static efl_access_object_can_highlight_get_delegate efl_access_object_can_highlight_get_static_delegate;
2334
2335
2336         private delegate void efl_access_object_can_highlight_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_highlight);
2337
2338
2339         public delegate void efl_access_object_can_highlight_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_highlight);
2340
2341         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");
2342
2343         private static void can_highlight_set(System.IntPtr obj, System.IntPtr pd, bool can_highlight)
2344         {
2345             Eina.Log.Debug("function efl_access_object_can_highlight_set was called");
2346             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2347             if (ws != null)
2348             {
2349
2350                 try
2351                 {
2352                     ((IObject)ws.Target).SetCanHighlight(can_highlight);
2353                 }
2354                 catch (Exception e)
2355                 {
2356                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2357                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2358                 }
2359
2360
2361             }
2362             else
2363             {
2364                 efl_access_object_can_highlight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_highlight);
2365             }
2366         }
2367
2368         private static efl_access_object_can_highlight_set_delegate efl_access_object_can_highlight_set_static_delegate;
2369
2370         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2371         private delegate System.String efl_access_object_translation_domain_get_delegate(System.IntPtr obj, System.IntPtr pd);
2372
2373         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2374         public delegate System.String efl_access_object_translation_domain_get_api_delegate(System.IntPtr obj);
2375
2376         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");
2377
2378         private static System.String translation_domain_get(System.IntPtr obj, System.IntPtr pd)
2379         {
2380             Eina.Log.Debug("function efl_access_object_translation_domain_get was called");
2381             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2382             if (ws != null)
2383             {
2384             System.String _ret_var = default(System.String);
2385                 try
2386                 {
2387                     _ret_var = ((IObject)ws.Target).GetTranslationDomain();
2388                 }
2389                 catch (Exception e)
2390                 {
2391                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2392                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2393                 }
2394
2395         return _ret_var;
2396
2397             }
2398             else
2399             {
2400                 return efl_access_object_translation_domain_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2401             }
2402         }
2403
2404         private static efl_access_object_translation_domain_get_delegate efl_access_object_translation_domain_get_static_delegate;
2405
2406
2407         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);
2408
2409
2410         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);
2411
2412         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");
2413
2414         private static void translation_domain_set(System.IntPtr obj, System.IntPtr pd, System.String domain)
2415         {
2416             Eina.Log.Debug("function efl_access_object_translation_domain_set was called");
2417             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2418             if (ws != null)
2419             {
2420
2421                 try
2422                 {
2423                     ((IObject)ws.Target).SetTranslationDomain(domain);
2424                 }
2425                 catch (Exception e)
2426                 {
2427                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2428                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2429                 }
2430
2431
2432             }
2433             else
2434             {
2435                 efl_access_object_translation_domain_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), domain);
2436             }
2437         }
2438
2439         private static efl_access_object_translation_domain_set_delegate efl_access_object_translation_domain_set_static_delegate;
2440
2441         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2442         private delegate Efl.Object efl_access_object_access_root_get_delegate();
2443
2444         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2445         public delegate Efl.Object efl_access_object_access_root_get_api_delegate();
2446
2447         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");
2448
2449         private static Efl.Object access_root_get(System.IntPtr obj, System.IntPtr pd)
2450         {
2451             Eina.Log.Debug("function efl_access_object_access_root_get was called");
2452             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2453             if (ws != null)
2454             {
2455             Efl.Object _ret_var = default(Efl.Object);
2456                 try
2457                 {
2458                     _ret_var = IObjectConcrete.GetAccessRoot();
2459                 }
2460                 catch (Exception e)
2461                 {
2462                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2463                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2464                 }
2465
2466         return _ret_var;
2467
2468             }
2469             else
2470             {
2471                 return efl_access_object_access_root_get_ptr.Value.Delegate();
2472             }
2473         }
2474
2475         [return: MarshalAs(UnmanagedType.U1)]
2476         private delegate bool efl_access_object_gesture_do_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Access.GestureInfo.NativeStruct gesture_info);
2477
2478         [return: MarshalAs(UnmanagedType.U1)]
2479         public delegate bool efl_access_object_gesture_do_api_delegate(System.IntPtr obj,  Efl.Access.GestureInfo.NativeStruct gesture_info);
2480
2481         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");
2482
2483         private static bool gesture_do(System.IntPtr obj, System.IntPtr pd, Efl.Access.GestureInfo.NativeStruct gesture_info)
2484         {
2485             Eina.Log.Debug("function efl_access_object_gesture_do was called");
2486             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2487             if (ws != null)
2488             {
2489         Efl.Access.GestureInfo _in_gesture_info = gesture_info;
2490                             bool _ret_var = default(bool);
2491                 try
2492                 {
2493                     _ret_var = ((IObject)ws.Target).GestureDo(_in_gesture_info);
2494                 }
2495                 catch (Exception e)
2496                 {
2497                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2498                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2499                 }
2500
2501                         return _ret_var;
2502
2503             }
2504             else
2505             {
2506                 return efl_access_object_gesture_do_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gesture_info);
2507             }
2508         }
2509
2510         private static efl_access_object_gesture_do_delegate efl_access_object_gesture_do_static_delegate;
2511
2512
2513         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);
2514
2515
2516         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);
2517
2518         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");
2519
2520         private static void attribute_append(System.IntPtr obj, System.IntPtr pd, System.String key, System.String value)
2521         {
2522             Eina.Log.Debug("function efl_access_object_attribute_append was called");
2523             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2524             if (ws != null)
2525             {
2526
2527                 try
2528                 {
2529                     ((IObject)ws.Target).AppendAttribute(key, value);
2530                 }
2531                 catch (Exception e)
2532                 {
2533                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2534                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2535                 }
2536
2537
2538             }
2539             else
2540             {
2541                 efl_access_object_attribute_append_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key, value);
2542             }
2543         }
2544
2545         private static efl_access_object_attribute_append_delegate efl_access_object_attribute_append_static_delegate;
2546
2547
2548         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);
2549
2550
2551         public delegate void efl_access_object_attribute_del_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
2552
2553         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");
2554
2555         private static void attribute_del(System.IntPtr obj, System.IntPtr pd, System.String key)
2556         {
2557             Eina.Log.Debug("function efl_access_object_attribute_del was called");
2558             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2559             if (ws != null)
2560             {
2561
2562                 try
2563                 {
2564                     ((IObject)ws.Target).DelAttribute(key);
2565                 }
2566                 catch (Exception e)
2567                 {
2568                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2569                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2570                 }
2571
2572
2573             }
2574             else
2575             {
2576                 efl_access_object_attribute_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
2577             }
2578         }
2579
2580         private static efl_access_object_attribute_del_delegate efl_access_object_attribute_del_static_delegate;
2581
2582
2583         private delegate void efl_access_object_attributes_clear_delegate(System.IntPtr obj, System.IntPtr pd);
2584
2585
2586         public delegate void efl_access_object_attributes_clear_api_delegate(System.IntPtr obj);
2587
2588         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");
2589
2590         private static void attributes_clear(System.IntPtr obj, System.IntPtr pd)
2591         {
2592             Eina.Log.Debug("function efl_access_object_attributes_clear was called");
2593             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2594             if (ws != null)
2595             {
2596
2597                 try
2598                 {
2599                     ((IObject)ws.Target).ClearAttributes();
2600                 }
2601                 catch (Exception e)
2602                 {
2603                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2604                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2605                 }
2606
2607
2608             }
2609             else
2610             {
2611                 efl_access_object_attributes_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2612             }
2613         }
2614
2615         private static efl_access_object_attributes_clear_delegate efl_access_object_attributes_clear_static_delegate;
2616
2617
2618         private delegate Efl.Access.Event.Handler efl_access_object_event_handler_add_delegate( Efl.EventCb cb,  System.IntPtr data);
2619
2620
2621         public delegate Efl.Access.Event.Handler efl_access_object_event_handler_add_api_delegate( Efl.EventCb cb,  System.IntPtr data);
2622
2623         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");
2624
2625         private static Efl.Access.Event.Handler event_handler_add(System.IntPtr obj, System.IntPtr pd, Efl.EventCb cb, System.IntPtr data)
2626         {
2627             Eina.Log.Debug("function efl_access_object_event_handler_add was called");
2628             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2629             if (ws != null)
2630             {
2631                                                             Efl.Access.Event.Handler _ret_var = default(Efl.Access.Event.Handler);
2632                 try
2633                 {
2634                     _ret_var = IObjectConcrete.AddEventHandler(cb, data);
2635                 }
2636                 catch (Exception e)
2637                 {
2638                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2639                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2640                 }
2641
2642                                         return _ret_var;
2643
2644             }
2645             else
2646             {
2647                 return efl_access_object_event_handler_add_ptr.Value.Delegate(cb, data);
2648             }
2649         }
2650
2651
2652         private delegate void efl_access_object_event_handler_del_delegate( Efl.Access.Event.Handler handler);
2653
2654
2655         public delegate void efl_access_object_event_handler_del_api_delegate( Efl.Access.Event.Handler handler);
2656
2657         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");
2658
2659         private static void event_handler_del(System.IntPtr obj, System.IntPtr pd, Efl.Access.Event.Handler handler)
2660         {
2661             Eina.Log.Debug("function efl_access_object_event_handler_del was called");
2662             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2663             if (ws != null)
2664             {
2665
2666                 try
2667                 {
2668                     IObjectConcrete.DelEventHandler(handler);
2669                 }
2670                 catch (Exception e)
2671                 {
2672                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2673                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2674                 }
2675
2676
2677             }
2678             else
2679             {
2680                 efl_access_object_event_handler_del_ptr.Value.Delegate(handler);
2681             }
2682         }
2683
2684
2685         private delegate void efl_access_object_event_emit_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject accessible,  System.IntPtr kw_event,  System.IntPtr event_info);
2686
2687
2688         public delegate void efl_access_object_event_emit_api_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject accessible,  System.IntPtr kw_event,  System.IntPtr event_info);
2689
2690         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");
2691
2692         private static void event_emit(System.IntPtr obj, System.IntPtr pd, Efl.Access.IObject accessible, System.IntPtr kw_event, System.IntPtr event_info)
2693         {
2694             Eina.Log.Debug("function efl_access_object_event_emit was called");
2695             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2696             if (ws != null)
2697             {
2698                 var _in_kw_event = Eina.PrimitiveConversion.PointerToManaged<Efl.EventDescription>(kw_event);
2699
2700                 try
2701                 {
2702                     IObjectConcrete.EmitEvent(accessible, _in_kw_event, event_info);
2703                 }
2704                 catch (Exception e)
2705                 {
2706                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2707                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2708                 }
2709
2710
2711             }
2712             else
2713             {
2714                 efl_access_object_event_emit_ptr.Value.Delegate(accessible, kw_event, event_info);
2715             }
2716         }
2717
2718         [return: MarshalAs(UnmanagedType.U1)]
2719         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject relation_object);
2720
2721         [return: MarshalAs(UnmanagedType.U1)]
2722         public delegate bool efl_access_object_relationship_append_api_delegate(System.IntPtr obj,  Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject relation_object);
2723
2724         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");
2725
2726         private static bool relationship_append(System.IntPtr obj, System.IntPtr pd, Efl.Access.RelationType type, Efl.Access.IObject relation_object)
2727         {
2728             Eina.Log.Debug("function efl_access_object_relationship_append was called");
2729             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2730             if (ws != null)
2731             {
2732                                                             bool _ret_var = default(bool);
2733                 try
2734                 {
2735                     _ret_var = ((IObject)ws.Target).AppendRelationship(type, relation_object);
2736                 }
2737                 catch (Exception e)
2738                 {
2739                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2740                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2741                 }
2742
2743                                         return _ret_var;
2744
2745             }
2746             else
2747             {
2748                 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);
2749             }
2750         }
2751
2752         private static efl_access_object_relationship_append_delegate efl_access_object_relationship_append_static_delegate;
2753
2754
2755         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.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject relation_object);
2756
2757
2758         public delegate void efl_access_object_relationship_remove_api_delegate(System.IntPtr obj,  Efl.Access.RelationType type, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Access.IObject relation_object);
2759
2760         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");
2761
2762         private static void relationship_remove(System.IntPtr obj, System.IntPtr pd, Efl.Access.RelationType type, Efl.Access.IObject relation_object)
2763         {
2764             Eina.Log.Debug("function efl_access_object_relationship_remove was called");
2765             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2766             if (ws != null)
2767             {
2768
2769                 try
2770                 {
2771                     ((IObject)ws.Target).RelationshipRemove(type, relation_object);
2772                 }
2773                 catch (Exception e)
2774                 {
2775                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2776                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2777                 }
2778
2779
2780             }
2781             else
2782             {
2783                 efl_access_object_relationship_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type, relation_object);
2784             }
2785         }
2786
2787         private static efl_access_object_relationship_remove_delegate efl_access_object_relationship_remove_static_delegate;
2788
2789
2790         private delegate void efl_access_object_relationships_clear_delegate(System.IntPtr obj, System.IntPtr pd);
2791
2792
2793         public delegate void efl_access_object_relationships_clear_api_delegate(System.IntPtr obj);
2794
2795         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");
2796
2797         private static void relationships_clear(System.IntPtr obj, System.IntPtr pd)
2798         {
2799             Eina.Log.Debug("function efl_access_object_relationships_clear was called");
2800             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2801             if (ws != null)
2802             {
2803
2804                 try
2805                 {
2806                     ((IObject)ws.Target).ClearRelationships();
2807                 }
2808                 catch (Exception e)
2809                 {
2810                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2811                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2812                 }
2813
2814
2815             }
2816             else
2817             {
2818                 efl_access_object_relationships_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2819             }
2820         }
2821
2822         private static efl_access_object_relationships_clear_delegate efl_access_object_relationships_clear_static_delegate;
2823
2824
2825         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);
2826
2827
2828         public delegate void efl_access_object_state_notify_api_delegate(System.IntPtr obj,  Efl.Access.StateSet state_types_mask, [MarshalAs(UnmanagedType.U1)] bool recursive);
2829
2830         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");
2831
2832         private static void state_notify(System.IntPtr obj, System.IntPtr pd, Efl.Access.StateSet state_types_mask, bool recursive)
2833         {
2834             Eina.Log.Debug("function efl_access_object_state_notify was called");
2835             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2836             if (ws != null)
2837             {
2838
2839                 try
2840                 {
2841                     ((IObject)ws.Target).StateNotify(state_types_mask, recursive);
2842                 }
2843                 catch (Exception e)
2844                 {
2845                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2846                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2847                 }
2848
2849
2850             }
2851             else
2852             {
2853                 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);
2854             }
2855         }
2856
2857         private static efl_access_object_state_notify_delegate efl_access_object_state_notify_static_delegate;
2858
2859         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2860
2861 }
2862 }
2863 }
2864
2865 }
2866
2867 namespace Efl {
2868
2869 namespace Access {
2870
2871 /// <summary>Type of accessibility object</summary>
2872 [Efl.Eo.BindingEntity]
2873 public enum Type
2874 {
2875 /// <summary>default accessible object</summary>
2876 Regular = 0,
2877 /// <summary>skip object and its children in accessibility hierarchy</summary>
2878 Disabled = 1,
2879 /// <summary>skip object in accessibility hierarchy</summary>
2880 Skipped = 2,
2881 }
2882
2883 }
2884
2885 }
2886
2887 namespace Efl {
2888
2889 namespace Access {
2890
2891 /// <summary>Describes the role of an object visible to Accessibility Clients.</summary>
2892 [Efl.Eo.BindingEntity]
2893 public enum Role
2894 {
2895 /// <summary>Role: invalid</summary>
2896 Invalid = 0,
2897 /// <summary>Role: accelerator label</summary>
2898 AcceleratorLabel = 1,
2899 /// <summary>Role: alert</summary>
2900 Alert = 2,
2901 /// <summary>Role: animation</summary>
2902 Animation = 3,
2903 /// <summary>Role: arrow</summary>
2904 Arrow = 4,
2905 /// <summary>Role: calendar</summary>
2906 Calendar = 5,
2907 /// <summary>Role: canvas</summary>
2908 Canvas = 6,
2909 /// <summary>Role: check box</summary>
2910 CheckBox = 7,
2911 /// <summary>Role: check menu item</summary>
2912 CheckMenuItem = 8,
2913 /// <summary>Role: color chooser</summary>
2914 ColorChooser = 9,
2915 /// <summary>Role: column header</summary>
2916 ColumnHeader = 10,
2917 /// <summary>Role: combo box</summary>
2918 ComboBox = 11,
2919 /// <summary>Role: data editor</summary>
2920 DateEditor = 12,
2921 /// <summary>Role: desktop icon</summary>
2922 DesktopIcon = 13,
2923 /// <summary>Role: desktop frame</summary>
2924 DesktopFrame = 14,
2925 /// <summary>Role: dial</summary>
2926 Dial = 15,
2927 /// <summary>Role: dialog</summary>
2928 Dialog = 16,
2929 /// <summary>Role: directory pane</summary>
2930 DirectoryPane = 17,
2931 /// <summary>Role: drawing area</summary>
2932 DrawingArea = 18,
2933 /// <summary>Role: file chooser</summary>
2934 FileChooser = 19,
2935 /// <summary>Role: filler</summary>
2936 Filler = 20,
2937 /// <summary>Role: focus traversable</summary>
2938 FocusTraversable = 21,
2939 /// <summary>Role: font chooser</summary>
2940 FontChooser = 22,
2941 /// <summary>Role: frame</summary>
2942 Frame = 23,
2943 /// <summary>Role: glass pane</summary>
2944 GlassPane = 24,
2945 /// <summary>Role: HTML container</summary>
2946 HtmlContainer = 25,
2947 /// <summary>Role: icon</summary>
2948 Icon = 26,
2949 /// <summary>Role: image</summary>
2950 Image = 27,
2951 /// <summary>Role: internal frame</summary>
2952 InternalFrame = 28,
2953 /// <summary>Role: label</summary>
2954 Label = 29,
2955 /// <summary>Role: layered pane</summary>
2956 LayeredPane = 30,
2957 /// <summary>Role: list</summary>
2958 List = 31,
2959 /// <summary>Role: list item</summary>
2960 ListItem = 32,
2961 /// <summary>Role: menu</summary>
2962 Menu = 33,
2963 /// <summary>Role: menu bar</summary>
2964 MenuBar = 34,
2965 /// <summary>Role: menu item</summary>
2966 MenuItem = 35,
2967 /// <summary>Role: option pane</summary>
2968 OptionPane = 36,
2969 /// <summary>Role: page tab</summary>
2970 PageTab = 37,
2971 /// <summary>Role: page tab list</summary>
2972 PageTabList = 38,
2973 /// <summary>Role: panel</summary>
2974 Panel = 39,
2975 /// <summary>Role: password text</summary>
2976 PasswordText = 40,
2977 /// <summary>Role: popup menu</summary>
2978 PopupMenu = 41,
2979 /// <summary>Role: progress bar</summary>
2980 ProgressBar = 42,
2981 /// <summary>Role: push button</summary>
2982 PushButton = 43,
2983 /// <summary>Role: radio button</summary>
2984 RadioButton = 44,
2985 /// <summary>Role: radio menu item</summary>
2986 RadioMenuItem = 45,
2987 /// <summary>Role: root pane</summary>
2988 RootPane = 46,
2989 /// <summary>Role: row header</summary>
2990 RowHeader = 47,
2991 /// <summary>Role: scroll bar</summary>
2992 ScrollBar = 48,
2993 /// <summary>Role: scroll pane</summary>
2994 ScrollPane = 49,
2995 /// <summary>Role: separator</summary>
2996 Separator = 50,
2997 /// <summary>Role: slider</summary>
2998 Slider = 51,
2999 /// <summary>Role: spin button</summary>
3000 SpinButton = 52,
3001 /// <summary>Role: split pane</summary>
3002 SplitPane = 53,
3003 /// <summary>Role: status bar</summary>
3004 StatusBar = 54,
3005 /// <summary>Role: table</summary>
3006 Table = 55,
3007 /// <summary>Role: table cell</summary>
3008 TableCell = 56,
3009 /// <summary>Role: table column header</summary>
3010 TableColumnHeader = 57,
3011 /// <summary>Role: table row header</summary>
3012 TableRowHeader = 58,
3013 /// <summary>Role: tearoff menu item</summary>
3014 TearoffMenuItem = 59,
3015 /// <summary>Role: terminal</summary>
3016 Terminal = 60,
3017 /// <summary>Role: text</summary>
3018 Text = 61,
3019 /// <summary>Role: toggle button</summary>
3020 ToggleButton = 62,
3021 /// <summary>Role: too bar</summary>
3022 ToolBar = 63,
3023 /// <summary>Role: tool tip</summary>
3024 ToolTip = 64,
3025 /// <summary>Role: tree</summary>
3026 Tree = 65,
3027 /// <summary>Role: tree table</summary>
3028 TreeTable = 66,
3029 /// <summary>Role: unknown</summary>
3030 Unknown = 67,
3031 /// <summary>Role: viewport</summary>
3032 Viewport = 68,
3033 /// <summary>Role: window</summary>
3034 Window = 69,
3035 /// <summary>Role: extended</summary>
3036 Extended = 70,
3037 /// <summary>Role: header</summary>
3038 Header = 71,
3039 /// <summary>Role: footer</summary>
3040 Footer = 72,
3041 /// <summary>Role: paragraph</summary>
3042 Paragraph = 73,
3043 /// <summary>Role: ruler</summary>
3044 Ruler = 74,
3045 /// <summary>Role: application</summary>
3046 Application = 75,
3047 /// <summary>Role: autocomplete</summary>
3048 Autocomplete = 76,
3049 /// <summary>Role: editbar</summary>
3050 Editbar = 77,
3051 /// <summary>Role: embedded</summary>
3052 Embedded = 78,
3053 /// <summary>Role: entry</summary>
3054 Entry = 79,
3055 /// <summary>Role: chart</summary>
3056 Chart = 80,
3057 /// <summary>Role: caption</summary>
3058 Caption = 81,
3059 /// <summary>Role: document frame</summary>
3060 DocumentFrame = 82,
3061 /// <summary>Role: heading</summary>
3062 Heading = 83,
3063 /// <summary>Role: page</summary>
3064 Page = 84,
3065 /// <summary>Role: section</summary>
3066 Section = 85,
3067 /// <summary>Role: redundant object</summary>
3068 RedundantObject = 86,
3069 /// <summary>Role: form</summary>
3070 Form = 87,
3071 /// <summary>Role: link</summary>
3072 Link = 88,
3073 /// <summary>Role: input method window</summary>
3074 InputMethodWindow = 89,
3075 /// <summary>Role: table row</summary>
3076 TableRow = 90,
3077 /// <summary>Role: table item</summary>
3078 TreeItem = 91,
3079 /// <summary>Role: document spreadsheet</summary>
3080 DocumentSpreadsheet = 92,
3081 /// <summary>Role: document presentation</summary>
3082 DocumentPresentation = 93,
3083 /// <summary>Role: document text</summary>
3084 DocumentText = 94,
3085 /// <summary>Role: document web</summary>
3086 DocumentWeb = 95,
3087 /// <summary>Role: document email</summary>
3088 DocumentEmail = 96,
3089 /// <summary>Role: comment</summary>
3090 Comment = 97,
3091 /// <summary>Role: list box</summary>
3092 ListBox = 98,
3093 /// <summary>Role: grouping</summary>
3094 Grouping = 99,
3095 /// <summary>Role: image map</summary>
3096 ImageMap = 100,
3097 /// <summary>Role: notification</summary>
3098 Notification = 101,
3099 /// <summary>Role: info bar</summary>
3100 InfoBar = 102,
3101 /// <summary>Last enum entry sentinel</summary>
3102 LastDefined = 103,
3103 }
3104
3105 }
3106
3107 }
3108
3109 namespace Efl {
3110
3111 namespace Access {
3112
3113 /// <summary>Describes the possible states for an object visible to accessibility clients.</summary>
3114 [Efl.Eo.BindingEntity]
3115 public enum StateType
3116 {
3117 /// <summary>State: invalid</summary>
3118 Invalid = 0,
3119 /// <summary>State: active</summary>
3120 Active = 1,
3121 /// <summary>State: armed</summary>
3122 Armed = 2,
3123 /// <summary>State: busy</summary>
3124 Busy = 3,
3125 /// <summary>State: checked</summary>
3126 Checked = 4,
3127 /// <summary>State: collapsed</summary>
3128 Collapsed = 5,
3129 /// <summary>State: defunct</summary>
3130 Defunct = 6,
3131 /// <summary>State: editable</summary>
3132 Editable = 7,
3133 /// <summary>State: enabled</summary>
3134 Enabled = 8,
3135 /// <summary>State: expandable</summary>
3136 Expandable = 9,
3137 /// <summary>State: expanded</summary>
3138 Expanded = 10,
3139 /// <summary>State: focusable</summary>
3140 Focusable = 11,
3141 /// <summary>State: focused</summary>
3142 Focused = 12,
3143 /// <summary>State: has a tooltip</summary>
3144 HasTooltip = 13,
3145 /// <summary>State: horizontal</summary>
3146 Horizontal = 14,
3147 /// <summary>State: minimized</summary>
3148 Minimized = 15,
3149 /// <summary>State: modal</summary>
3150 Modal = 16,
3151 /// <summary>State: multi line</summary>
3152 MultiLine = 17,
3153 /// <summary>State: multiselectable</summary>
3154 Multiselectable = 18,
3155 /// <summary>State: opaque</summary>
3156 Opaque = 19,
3157 /// <summary>State: pressed</summary>
3158 Pressed = 20,
3159 /// <summary>State: resizable</summary>
3160 Resizable = 21,
3161 /// <summary>State: selectable</summary>
3162 Selectable = 22,
3163 /// <summary>State: selected</summary>
3164 Selected = 23,
3165 /// <summary>State: sensitive</summary>
3166 Sensitive = 24,
3167 /// <summary>State: showing</summary>
3168 Showing = 25,
3169 /// <summary>State: single line</summary>
3170 SingleLine = 26,
3171 /// <summary>State: stale</summary>
3172 Stale = 27,
3173 /// <summary>State: transient</summary>
3174 Transient = 28,
3175 /// <summary>State: vertical</summary>
3176 Vertical = 29,
3177 /// <summary>State: visible</summary>
3178 Visible = 30,
3179 /// <summary>State: manage descendants</summary>
3180 ManagesDescendants = 31,
3181 /// <summary>State: indeterminate</summary>
3182 Indeterminate = 32,
3183 /// <summary>State: required</summary>
3184 Required = 33,
3185 /// <summary>State: truncated</summary>
3186 Truncated = 34,
3187 /// <summary>State: animated</summary>
3188 Animated = 35,
3189 /// <summary>State: invalid entry</summary>
3190 InvalidEntry = 36,
3191 /// <summary>State: supports autocompletion</summary>
3192 SupportsAutocompletion = 37,
3193 /// <summary>State: selectable text</summary>
3194 SelectableText = 38,
3195 /// <summary>State: is default</summary>
3196 IsDefault = 39,
3197 /// <summary>State: visited</summary>
3198 Visited = 40,
3199 /// <summary>State: checkable</summary>
3200 Checkable = 41,
3201 /// <summary>State: has popup</summary>
3202 HasPopup = 42,
3203 /// <summary>State: read only</summary>
3204 ReadOnly = 43,
3205 /// <summary>State: highlighted</summary>
3206 Highlighted = 44,
3207 /// <summary>State: highlightable</summary>
3208 Highlightable = 45,
3209 /// <summary>Last enum entry sentinel</summary>
3210 LastDefined = 46,
3211 }
3212
3213 }
3214
3215 }
3216
3217 namespace Efl {
3218
3219 namespace Access {
3220
3221 /// <summary>Describes the relationship between two objects.</summary>
3222 [Efl.Eo.BindingEntity]
3223 public enum RelationType
3224 {
3225 /// <summary>No relation</summary>
3226 Null = 0,
3227 /// <summary>Label for relation</summary>
3228 LabelFor = 1,
3229 /// <summary>Labelled by relation</summary>
3230 LabelledBy = 2,
3231 /// <summary>Controller for relation</summary>
3232 ControllerFor = 3,
3233 /// <summary>Controlled by relation</summary>
3234 ControlledBy = 4,
3235 /// <summary>Member of relation</summary>
3236 MemberOf = 5,
3237 /// <summary>Tooltip for relation</summary>
3238 TooltipFor = 6,
3239 /// <summary>Node child of relation</summary>
3240 NodeChildOf = 7,
3241 /// <summary>Node parent of relation</summary>
3242 NodeParentOf = 8,
3243 /// <summary>Extended relation</summary>
3244 Extended = 9,
3245 /// <summary>Flows to relation</summary>
3246 FlowsTo = 10,
3247 /// <summary>Flows from relation</summary>
3248 FlowsFrom = 11,
3249 /// <summary>Subwindow of relation</summary>
3250 SubwindowOf = 12,
3251 /// <summary>Embeds relation</summary>
3252 Embeds = 13,
3253 /// <summary>Embedded by relation</summary>
3254 EmbeddedBy = 14,
3255 /// <summary>Popup for relation</summary>
3256 PopupFor = 15,
3257 /// <summary>Parent window of relation</summary>
3258 ParentWindowOf = 16,
3259 /// <summary>Description for relation</summary>
3260 DescriptionFor = 17,
3261 /// <summary>Described by relation</summary>
3262 DescribedBy = 18,
3263 /// <summary>Last enum entry sentinel</summary>
3264 LastDefined = 19,
3265 }
3266
3267 }
3268
3269 }
3270
3271 namespace Efl {
3272
3273 namespace Access {
3274
3275 namespace Reading {
3276
3277 namespace Info {
3278
3279 /// <summary>The accessible Reading information type that can be read.</summary>
3280 [Efl.Eo.BindingEntity]
3281 public enum Type
3282 {
3283 /// <summary>Name should be read</summary>
3284 Name = 1,
3285 /// <summary>Role should be read</summary>
3286 Role = 2,
3287 /// <summary>description should be read.</summary>
3288 Description = 4,
3289 /// <summary>State should be read.</summary>
3290 State = 8,
3291 }
3292
3293 }
3294
3295 }
3296
3297 }
3298
3299 }
3300
3301 namespace Efl {
3302
3303 namespace Access {
3304
3305 [Efl.Eo.BindingEntity]
3306 public enum Gesture
3307 {
3308 OneFingerHover = 0,
3309 TwoFingersHover = 1,
3310 ThreeFingersHover = 2,
3311 OneFingerFlickLeft = 3,
3312 OneFingerFlickRight = 4,
3313 OneFingerFlickUp = 5,
3314 OneFingerFlickDown = 6,
3315 TwoFingersFlickLeft = 7,
3316 TwoFingersFlickRight = 8,
3317 TwoFingersFlickUp = 9,
3318 TwoFingersFlickDown = 10,
3319 ThreeFingersFlickLeft = 11,
3320 ThreeFingersFlickRight = 12,
3321 ThreeFingersFlickUp = 13,
3322 ThreeFingersFlickDown = 14,
3323 OneFingerSingleTap = 15,
3324 OneFingerDoubleTap = 16,
3325 OneFingerTripleTap = 17,
3326 TwoFingersSingleTap = 18,
3327 TwoFingersDoubleTap = 19,
3328 TwoFingersTripleTap = 20,
3329 ThreeFingersSingleTap = 21,
3330 ThreeFingersDoubleTap = 22,
3331 ThreeFingersTripleTap = 23,
3332 OneFingerFlickLeftReturn = 24,
3333 OneFingerFlickRightReturn = 25,
3334 OneFingerFlickUpReturn = 26,
3335 OneFingerFlickDownReturn = 27,
3336 TwoFingersFlickLeftReturn = 28,
3337 TwoFingersFlickRightReturn = 29,
3338 TwoFingersFlickUpReturn = 30,
3339 TwoFingersFlickDownReturn = 31,
3340 ThreeFingersFlickLeftReturn = 32,
3341 ThreeFingersFlickRightReturn = 33,
3342 ThreeFingersFlickUpReturn = 34,
3343 ThreeFingersFlickDownReturn = 35,
3344 }
3345
3346 }
3347
3348 }
3349
3350 namespace Efl {
3351
3352 namespace Access {
3353
3354 [Efl.Eo.BindingEntity]
3355 public enum GestureState
3356 {
3357 Start = 0,
3358 Move = 1,
3359 End = 2,
3360 Abort = 3,
3361 }
3362
3363 }
3364
3365 }
3366
3367 namespace Efl {
3368
3369 namespace Access {
3370
3371 namespace Event {
3372
3373 /// <summary>Accessibility event listener</summary>
3374 [StructLayout(LayoutKind.Sequential)]
3375 [Efl.Eo.BindingEntity]
3376 public struct Handler
3377 {
3378     ///<summary>Placeholder field</summary>
3379     public IntPtr field;
3380     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3381     ///<param name="ptr">Native pointer to be converted.</param>
3382     public static implicit operator Handler(IntPtr ptr)
3383     {
3384         var tmp = (Handler.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Handler.NativeStruct));
3385         return tmp;
3386     }
3387
3388     #pragma warning disable CS1591
3389
3390     ///<summary>Internal wrapper for struct Handler.</summary>
3391     [StructLayout(LayoutKind.Sequential)]
3392     public struct NativeStruct
3393     {
3394         internal IntPtr field;
3395         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3396         public static implicit operator Handler.NativeStruct(Handler _external_struct)
3397         {
3398             var _internal_struct = new Handler.NativeStruct();
3399             return _internal_struct;
3400         }
3401
3402         ///<summary>Implicit conversion to the managed representation.</summary>
3403         public static implicit operator Handler(Handler.NativeStruct _internal_struct)
3404         {
3405             var _external_struct = new Handler();
3406             return _external_struct;
3407         }
3408
3409     }
3410
3411     #pragma warning restore CS1591
3412
3413 }
3414
3415 }
3416
3417 }
3418
3419 }
3420
3421 namespace Efl {
3422
3423 namespace Access {
3424
3425 namespace Event {
3426
3427 namespace StateChanged {
3428
3429 /// <summary>Accessibility state changed event data</summary>
3430 [StructLayout(LayoutKind.Sequential)]
3431 [Efl.Eo.BindingEntity]
3432 public struct Data
3433 {
3434     /// <summary>Type of the state changed event</summary>
3435     public Efl.Access.StateType Type;
3436     /// <summary>New value</summary>
3437     public bool New_value;
3438     ///<summary>Constructor for Data.</summary>
3439     public Data(
3440         Efl.Access.StateType Type = default(Efl.Access.StateType),
3441         bool New_value = default(bool)    )
3442     {
3443         this.Type = Type;
3444         this.New_value = New_value;
3445     }
3446
3447     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3448     ///<param name="ptr">Native pointer to be converted.</param>
3449     public static implicit operator Data(IntPtr ptr)
3450     {
3451         var tmp = (Data.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Data.NativeStruct));
3452         return tmp;
3453     }
3454
3455     #pragma warning disable CS1591
3456
3457     ///<summary>Internal wrapper for struct Data.</summary>
3458     [StructLayout(LayoutKind.Sequential)]
3459     public struct NativeStruct
3460     {
3461
3462         public Efl.Access.StateType Type;
3463         ///<summary>Internal wrapper for field New_value</summary>
3464         public System.Byte New_value;
3465         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3466         public static implicit operator Data.NativeStruct(Data _external_struct)
3467         {
3468             var _internal_struct = new Data.NativeStruct();
3469             _internal_struct.Type = _external_struct.Type;
3470             _internal_struct.New_value = _external_struct.New_value ? (byte)1 : (byte)0;
3471             return _internal_struct;
3472         }
3473
3474         ///<summary>Implicit conversion to the managed representation.</summary>
3475         public static implicit operator Data(Data.NativeStruct _internal_struct)
3476         {
3477             var _external_struct = new Data();
3478             _external_struct.Type = _internal_struct.Type;
3479             _external_struct.New_value = _internal_struct.New_value != 0;
3480             return _external_struct;
3481         }
3482
3483     }
3484
3485     #pragma warning restore CS1591
3486
3487 }
3488
3489 }
3490
3491 }
3492
3493 }
3494
3495 }
3496
3497 namespace Efl {
3498
3499 namespace Access {
3500
3501 namespace Event {
3502
3503 namespace GeometryChanged {
3504
3505 /// <summary>Accessibility geometry changed event data</summary>
3506 [StructLayout(LayoutKind.Sequential)]
3507 [Efl.Eo.BindingEntity]
3508 public struct Data
3509 {
3510     /// <summary>X coordinate</summary>
3511     public int X;
3512     /// <summary>Y coordinate</summary>
3513     public int Y;
3514     /// <summary>Width</summary>
3515     public int Width;
3516     /// <summary>Height</summary>
3517     public int Height;
3518     ///<summary>Constructor for Data.</summary>
3519     public Data(
3520         int X = default(int),
3521         int Y = default(int),
3522         int Width = default(int),
3523         int Height = default(int)    )
3524     {
3525         this.X = X;
3526         this.Y = Y;
3527         this.Width = Width;
3528         this.Height = Height;
3529     }
3530
3531     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3532     ///<param name="ptr">Native pointer to be converted.</param>
3533     public static implicit operator Data(IntPtr ptr)
3534     {
3535         var tmp = (Data.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Data.NativeStruct));
3536         return tmp;
3537     }
3538
3539     #pragma warning disable CS1591
3540
3541     ///<summary>Internal wrapper for struct Data.</summary>
3542     [StructLayout(LayoutKind.Sequential)]
3543     public struct NativeStruct
3544     {
3545
3546         public int X;
3547
3548         public int Y;
3549
3550         public int Width;
3551
3552         public int Height;
3553         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3554         public static implicit operator Data.NativeStruct(Data _external_struct)
3555         {
3556             var _internal_struct = new Data.NativeStruct();
3557             _internal_struct.X = _external_struct.X;
3558             _internal_struct.Y = _external_struct.Y;
3559             _internal_struct.Width = _external_struct.Width;
3560             _internal_struct.Height = _external_struct.Height;
3561             return _internal_struct;
3562         }
3563
3564         ///<summary>Implicit conversion to the managed representation.</summary>
3565         public static implicit operator Data(Data.NativeStruct _internal_struct)
3566         {
3567             var _external_struct = new Data();
3568             _external_struct.X = _internal_struct.X;
3569             _external_struct.Y = _internal_struct.Y;
3570             _external_struct.Width = _internal_struct.Width;
3571             _external_struct.Height = _internal_struct.Height;
3572             return _external_struct;
3573         }
3574
3575     }
3576
3577     #pragma warning restore CS1591
3578
3579 }
3580
3581 }
3582
3583 }
3584
3585 }
3586
3587 }
3588
3589 namespace Efl {
3590
3591 namespace Access {
3592
3593 namespace Event {
3594
3595 namespace ChildrenChanged {
3596
3597 /// <summary>Accessibility children changed event data</summary>
3598 [StructLayout(LayoutKind.Sequential)]
3599 [Efl.Eo.BindingEntity]
3600 public struct Data
3601 {
3602     /// <summary>Child is added or not</summary>
3603     public bool Is_added;
3604     /// <summary>Child object</summary>
3605     public Efl.Object Child;
3606     ///<summary>Constructor for Data.</summary>
3607     public Data(
3608         bool Is_added = default(bool),
3609         Efl.Object Child = default(Efl.Object)    )
3610     {
3611         this.Is_added = Is_added;
3612         this.Child = Child;
3613     }
3614
3615     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3616     ///<param name="ptr">Native pointer to be converted.</param>
3617     public static implicit operator Data(IntPtr ptr)
3618     {
3619         var tmp = (Data.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Data.NativeStruct));
3620         return tmp;
3621     }
3622
3623     #pragma warning disable CS1591
3624
3625     ///<summary>Internal wrapper for struct Data.</summary>
3626     [StructLayout(LayoutKind.Sequential)]
3627     public struct NativeStruct
3628     {
3629         ///<summary>Internal wrapper for field Is_added</summary>
3630         public System.Byte Is_added;
3631         ///<summary>Internal wrapper for field Child</summary>
3632         public System.IntPtr Child;
3633         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3634         public static implicit operator Data.NativeStruct(Data _external_struct)
3635         {
3636             var _internal_struct = new Data.NativeStruct();
3637             _internal_struct.Is_added = _external_struct.Is_added ? (byte)1 : (byte)0;
3638             _internal_struct.Child = _external_struct.Child?.NativeHandle ?? System.IntPtr.Zero;
3639             return _internal_struct;
3640         }
3641
3642         ///<summary>Implicit conversion to the managed representation.</summary>
3643         public static implicit operator Data(Data.NativeStruct _internal_struct)
3644         {
3645             var _external_struct = new Data();
3646             _external_struct.Is_added = _internal_struct.Is_added != 0;
3647
3648             _external_struct.Child = (Efl.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Child);
3649             return _external_struct;
3650         }
3651
3652     }
3653
3654     #pragma warning restore CS1591
3655
3656 }
3657
3658 }
3659
3660 }
3661
3662 }
3663
3664 }
3665
3666 namespace Efl {
3667
3668 namespace Access {
3669
3670 /// <summary>Accessibility Attribute</summary>
3671 [StructLayout(LayoutKind.Sequential)]
3672 [Efl.Eo.BindingEntity]
3673 public struct Attribute
3674 {
3675     /// <summary>Attribute key</summary>
3676     public System.String Key;
3677     /// <summary>Attribute value</summary>
3678     public System.String Value;
3679     ///<summary>Constructor for Attribute.</summary>
3680     public Attribute(
3681         System.String Key = default(System.String),
3682         System.String Value = default(System.String)    )
3683     {
3684         this.Key = Key;
3685         this.Value = Value;
3686     }
3687
3688     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3689     ///<param name="ptr">Native pointer to be converted.</param>
3690     public static implicit operator Attribute(IntPtr ptr)
3691     {
3692         var tmp = (Attribute.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Attribute.NativeStruct));
3693         return tmp;
3694     }
3695
3696     #pragma warning disable CS1591
3697
3698     ///<summary>Internal wrapper for struct Attribute.</summary>
3699     [StructLayout(LayoutKind.Sequential)]
3700     public struct NativeStruct
3701     {
3702         ///<summary>Internal wrapper for field Key</summary>
3703         public System.IntPtr Key;
3704         ///<summary>Internal wrapper for field Value</summary>
3705         public System.IntPtr Value;
3706         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3707         public static implicit operator Attribute.NativeStruct(Attribute _external_struct)
3708         {
3709             var _internal_struct = new Attribute.NativeStruct();
3710             _internal_struct.Key = Eina.MemoryNative.StrDup(_external_struct.Key);
3711             _internal_struct.Value = Eina.MemoryNative.StrDup(_external_struct.Value);
3712             return _internal_struct;
3713         }
3714
3715         ///<summary>Implicit conversion to the managed representation.</summary>
3716         public static implicit operator Attribute(Attribute.NativeStruct _internal_struct)
3717         {
3718             var _external_struct = new Attribute();
3719             _external_struct.Key = Eina.StringConversion.NativeUtf8ToManagedString(_internal_struct.Key);
3720             _external_struct.Value = Eina.StringConversion.NativeUtf8ToManagedString(_internal_struct.Value);
3721             return _external_struct;
3722         }
3723
3724     }
3725
3726     #pragma warning restore CS1591
3727
3728 }
3729
3730 }
3731
3732 }
3733
3734 namespace Efl {
3735
3736 namespace Access {
3737
3738 /// <summary>Accessibility Relation</summary>
3739 [StructLayout(LayoutKind.Sequential)]
3740 [Efl.Eo.BindingEntity]
3741 public struct Relation
3742 {
3743     /// <summary>Relation type</summary>
3744     public Efl.Access.RelationType Type;
3745     /// <summary>List with relation objects</summary>
3746     public Eina.List<Efl.Object> Objects;
3747     ///<summary>Constructor for Relation.</summary>
3748     public Relation(
3749         Efl.Access.RelationType Type = default(Efl.Access.RelationType),
3750         Eina.List<Efl.Object> Objects = default(Eina.List<Efl.Object>)    )
3751     {
3752         this.Type = Type;
3753         this.Objects = Objects;
3754     }
3755
3756     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3757     ///<param name="ptr">Native pointer to be converted.</param>
3758     public static implicit operator Relation(IntPtr ptr)
3759     {
3760         var tmp = (Relation.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Relation.NativeStruct));
3761         return tmp;
3762     }
3763
3764     #pragma warning disable CS1591
3765
3766     ///<summary>Internal wrapper for struct Relation.</summary>
3767     [StructLayout(LayoutKind.Sequential)]
3768     public struct NativeStruct
3769     {
3770
3771         public Efl.Access.RelationType Type;
3772
3773         public System.IntPtr Objects;
3774         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3775         public static implicit operator Relation.NativeStruct(Relation _external_struct)
3776         {
3777             var _internal_struct = new Relation.NativeStruct();
3778             _internal_struct.Type = _external_struct.Type;
3779             _internal_struct.Objects = _external_struct.Objects.Handle;
3780             return _internal_struct;
3781         }
3782
3783         ///<summary>Implicit conversion to the managed representation.</summary>
3784         public static implicit operator Relation(Relation.NativeStruct _internal_struct)
3785         {
3786             var _external_struct = new Relation();
3787             _external_struct.Type = _internal_struct.Type;
3788             _external_struct.Objects = new Eina.List<Efl.Object>(_internal_struct.Objects, false, false);
3789             return _external_struct;
3790         }
3791
3792     }
3793
3794     #pragma warning restore CS1591
3795
3796 }
3797
3798 }
3799
3800 }
3801
3802 namespace Efl {
3803
3804 namespace Access {
3805
3806 [StructLayout(LayoutKind.Sequential)]
3807 [Efl.Eo.BindingEntity]
3808 public struct GestureInfo
3809 {
3810     /// <summary>Gesture type</summary>
3811     public Efl.Access.Gesture Type;
3812     /// <summary>start gesture x co-ordinate</summary>
3813     public int X_beg;
3814     /// <summary>start gesture y co-ordinate</summary>
3815     public int Y_beg;
3816     /// <summary>end gesture x co-ordinate</summary>
3817     public int X_end;
3818     /// <summary>end gesture y co-ordinate</summary>
3819     public int Y_end;
3820     /// <summary>state of gesture</summary>
3821     public Efl.Access.GestureState State;
3822     /// <summary>gesture occurance time</summary>
3823     public uint Event_time;
3824     ///<summary>Constructor for GestureInfo.</summary>
3825     public GestureInfo(
3826         Efl.Access.Gesture Type = default(Efl.Access.Gesture),
3827         int X_beg = default(int),
3828         int Y_beg = default(int),
3829         int X_end = default(int),
3830         int Y_end = default(int),
3831         Efl.Access.GestureState State = default(Efl.Access.GestureState),
3832         uint Event_time = default(uint)    )
3833     {
3834         this.Type = Type;
3835         this.X_beg = X_beg;
3836         this.Y_beg = Y_beg;
3837         this.X_end = X_end;
3838         this.Y_end = Y_end;
3839         this.State = State;
3840         this.Event_time = Event_time;
3841     }
3842
3843     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
3844     ///<param name="ptr">Native pointer to be converted.</param>
3845     public static implicit operator GestureInfo(IntPtr ptr)
3846     {
3847         var tmp = (GestureInfo.NativeStruct)Marshal.PtrToStructure(ptr, typeof(GestureInfo.NativeStruct));
3848         return tmp;
3849     }
3850
3851     #pragma warning disable CS1591
3852
3853     ///<summary>Internal wrapper for struct GestureInfo.</summary>
3854     [StructLayout(LayoutKind.Sequential)]
3855     public struct NativeStruct
3856     {
3857
3858         public Efl.Access.Gesture Type;
3859
3860         public int X_beg;
3861
3862         public int Y_beg;
3863
3864         public int X_end;
3865
3866         public int Y_end;
3867
3868         public Efl.Access.GestureState State;
3869
3870         public uint Event_time;
3871         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
3872         public static implicit operator GestureInfo.NativeStruct(GestureInfo _external_struct)
3873         {
3874             var _internal_struct = new GestureInfo.NativeStruct();
3875             _internal_struct.Type = _external_struct.Type;
3876             _internal_struct.X_beg = _external_struct.X_beg;
3877             _internal_struct.Y_beg = _external_struct.Y_beg;
3878             _internal_struct.X_end = _external_struct.X_end;
3879             _internal_struct.Y_end = _external_struct.Y_end;
3880             _internal_struct.State = _external_struct.State;
3881             _internal_struct.Event_time = _external_struct.Event_time;
3882             return _internal_struct;
3883         }
3884
3885         ///<summary>Implicit conversion to the managed representation.</summary>
3886         public static implicit operator GestureInfo(GestureInfo.NativeStruct _internal_struct)
3887         {
3888             var _external_struct = new GestureInfo();
3889             _external_struct.Type = _internal_struct.Type;
3890             _external_struct.X_beg = _internal_struct.X_beg;
3891             _external_struct.Y_beg = _internal_struct.Y_beg;
3892             _external_struct.X_end = _internal_struct.X_end;
3893             _external_struct.Y_end = _internal_struct.Y_end;
3894             _external_struct.State = _internal_struct.State;
3895             _external_struct.Event_time = _internal_struct.Event_time;
3896             return _external_struct;
3897         }
3898
3899     }
3900
3901     #pragma warning restore CS1591
3902
3903 }
3904
3905 }
3906
3907 }
3908