internals/src/EflSharp/EflSharp/efl/efl_access_selection.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>Elementary access selection interface</summary>
  13 [Efl.Access.ISelectionConcrete.NativeMethods]
  14 public interface ISelection :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Gets the number of currently selected children</summary>
  18 /// <returns>Number of currently selected children</returns>
  19 int GetSelectedChildrenCount();
  20     /// <summary>Gets child for given child index</summary>
  21 /// <param name="selected_child_index">Index of child</param>
  22 /// <returns>Child object</returns>
  23 Efl.Object GetSelectedChild(int selected_child_index);
  24     /// <summary>Adds selection for given child index</summary>
  25 /// <param name="child_index">Index of child</param>
  26 /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
  27 bool ChildSelect(int child_index);
  28     /// <summary>Removes selection for given child index</summary>
  29 /// <param name="child_index">Index of child</param>
  30 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  31 bool SelectedChildDeselect(int child_index);
  32     /// <summary>Determines if child specified by index is selected</summary>
  33 /// <param name="child_index">Index of child</param>
  34 /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
  35 bool IsChildSelected(int child_index);
  36     /// <summary>Adds selection for all children</summary>
  37 /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
  38 bool AllChildrenSelect();
  39     /// <summary>Clears the current selection</summary>
  40 /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
  41 bool ClearAccessSelection();
  42     /// <summary>Removes selection for given child index</summary>
  43 /// <param name="child_index">Index of child</param>
  44 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  45 bool ChildDeselect(int child_index);
  46                                     /// <summary>Called when selection has been changed.</summary>
  47     event EventHandler AccessSelectionChangedEvt;
  48     /// <summary>Gets the number of currently selected children</summary>
  49 /// <value>Number of currently selected children</value>
  50     int SelectedChildrenCount {
  51         get ;
  52     }
  53 }
  54 /// <summary>Elementary access selection interface</summary>
  55 sealed public class ISelectionConcrete :
  56
  57 ISelection
  58
  59 {
  60     ///<summary>Pointer to the native class description.</summary>
  61     public System.IntPtr NativeClass
  62     {
  63         get
  64         {
  65             if (((object)this).GetType() == typeof(ISelectionConcrete))
  66             {
  67                 return GetEflClassStatic();
  68             }
  69             else
  70             {
  71                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  72             }
  73         }
  74     }
  75
  76     private Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)> eoEvents = new Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)>();
  77     private readonly object eventLock = new object();
  78     private  System.IntPtr handle;
  79     ///<summary>Pointer to the native instance.</summary>
  80     public System.IntPtr NativeHandle
  81     {
  82         get { return handle; }
  83     }
  84
  85     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  86         efl_access_selection_interface_get();
  87     /// <summary>Initializes a new instance of the <see cref="ISelection"/> class.
  88     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  89     private ISelectionConcrete(System.IntPtr raw)
  90     {
  91         handle = raw;
  92     }
  93     ///<summary>Destructor.</summary>
  94     ~ISelectionConcrete()
  95     {
  96         Dispose(false);
  97     }
  98
  99     ///<summary>Releases the underlying native instance.</summary>
 100     private void Dispose(bool disposing)
 101     {
 102         if (handle != System.IntPtr.Zero)
 103         {
 104             IntPtr h = handle;
 105             handle = IntPtr.Zero;
 106
 107             IntPtr gcHandlePtr = IntPtr.Zero;
 108             if (eoEvents.Count != 0)
 109             {
 110                 GCHandle gcHandle = GCHandle.Alloc(eoEvents);
 111                 gcHandlePtr = GCHandle.ToIntPtr(gcHandle);
 112             }
 113
 114             if (disposing)
 115             {
 116                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 117             }
 118             else
 119             {
 120                 Monitor.Enter(Efl.All.InitLock);
 121                 if (Efl.All.MainLoopInitialized)
 122                 {
 123                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 124                 }
 125
 126                 Monitor.Exit(Efl.All.InitLock);
 127             }
 128         }
 129
 130     }
 131
 132     ///<summary>Releases the underlying native instance.</summary>
 133     public void Dispose()
 134     {
 135         Dispose(true);
 136         GC.SuppressFinalize(this);
 137     }
 138
 139     /// <summary>Verifies if the given object is equal to this one.</summary>
 140     /// <param name="instance">The object to compare to.</param>
 141     /// <returns>True if both objects point to the same native object.</returns>
 142     public override bool Equals(object instance)
 143     {
 144         var other = instance as Efl.Object;
 145         if (other == null)
 146         {
 147             return false;
 148         }
 149         return this.NativeHandle == other.NativeHandle;
 150     }
 151
 152     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 153     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 154     public override int GetHashCode()
 155     {
 156         return this.NativeHandle.ToInt32();
 157     }
 158
 159     /// <summary>Turns the native pointer into a string representation.</summary>
 160     /// <returns>A string with the type and the native pointer for this object.</returns>
 161     public override String ToString()
 162     {
 163         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 164     }
 165
 166     ///<summary>Adds a new event handler, registering it to the native event. For internal use only.</summary>
 167     ///<param name="lib">The name of the native library definining the event.</param>
 168     ///<param name="key">The name of the native event.</param>
 169     ///<param name="evtCaller">Delegate to be called by native code on event raising.</param>
 170     ///<param name="evtDelegate">Managed delegate that will be called by evtCaller on event raising.</param>
 171     private void AddNativeEventHandler(string lib, string key, Efl.EventCb evtCaller, object evtDelegate)
 172     {
 173         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 174         if (desc == IntPtr.Zero)
 175         {
 176             Eina.Log.Error($"Failed to get native event {key}");
 177         }
 178
 179         if (eoEvents.ContainsKey((desc, evtDelegate)))
 180         {
 181             Eina.Log.Warning($"Event proxy for event {key} already registered!");
 182             return;
 183         }
 184
 185         IntPtr evtCallerPtr = Marshal.GetFunctionPointerForDelegate(evtCaller);
 186         if (!Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evtCallerPtr, IntPtr.Zero))
 187         {
 188             Eina.Log.Error($"Failed to add event proxy for event {key}");
 189             return;
 190         }
 191
 192         eoEvents[(desc, evtDelegate)] = (evtCallerPtr, evtCaller);
 193         Eina.Error.RaiseIfUnhandledException();
 194     }
 195
 196     ///<summary>Removes the given event handler for the given event. For internal use only.</summary>
 197     ///<param name="lib">The name of the native library definining the event.</param>
 198     ///<param name="key">The name of the native event.</param>
 199     ///<param name="evtDelegate">The delegate to be removed.</param>
 200     private void RemoveNativeEventHandler(string lib, string key, object evtDelegate)
 201     {
 202         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 203         if (desc == IntPtr.Zero)
 204         {
 205             Eina.Log.Error($"Failed to get native event {key}");
 206             return;
 207         }
 208
 209         var evtPair = (desc, evtDelegate);
 210         if (eoEvents.TryGetValue(evtPair, out var caller))
 211         {
 212             if (!Efl.Eo.Globals.efl_event_callback_del(handle, desc, caller.evtCallerPtr, IntPtr.Zero))
 213             {
 214                 Eina.Log.Error($"Failed to remove event proxy for event {key}");
 215                 return;
 216             }
 217
 218             eoEvents.Remove(evtPair);
 219             Eina.Error.RaiseIfUnhandledException();
 220         }
 221         else
 222         {
 223             Eina.Log.Error($"Trying to remove proxy for event {key} when it is nothing registered.");
 224         }
 225     }
 226
 227     /// <summary>Called when selection has been changed.</summary>
 228     public event EventHandler AccessSelectionChangedEvt
 229     {
 230         add
 231         {
 232             lock (eventLock)
 233             {
 234                 var wRef = new WeakReference(this);
 235                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 236                 {
 237                     var obj = wRef.Target as Efl.Eo.IWrapper;
 238                     if (obj != null)
 239                     {
 240                         EventArgs args = EventArgs.Empty;
 241                         try
 242                         {
 243                             value?.Invoke(obj, args);
 244                         }
 245                         catch (Exception e)
 246                         {
 247                             Eina.Log.Error(e.ToString());
 248                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 249                         }
 250                     }
 251                 };
 252
 253                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 254                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 255             }
 256         }
 257
 258         remove
 259         {
 260             lock (eventLock)
 261             {
 262                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 263                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 264             }
 265         }
 266     }
 267     ///<summary>Method to raise event AccessSelectionChangedEvt.</summary>
 268     public void OnAccessSelectionChangedEvt(EventArgs e)
 269     {
 270         var key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 271         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 272         if (desc == IntPtr.Zero)
 273         {
 274             Eina.Log.Error($"Failed to get native event {key}");
 275             return;
 276         }
 277
 278         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 279     }
 280     /// <summary>Gets the number of currently selected children</summary>
 281     /// <returns>Number of currently selected children</returns>
 282     public int GetSelectedChildrenCount() {
 283          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_children_count_get_ptr.Value.Delegate(this.NativeHandle);
 284         Eina.Error.RaiseIfUnhandledException();
 285         return _ret_var;
 286  }
 287     /// <summary>Gets child for given child index</summary>
 288     /// <param name="selected_child_index">Index of child</param>
 289     /// <returns>Child object</returns>
 290     public Efl.Object GetSelectedChild(int selected_child_index) {
 291                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_child_get_ptr.Value.Delegate(this.NativeHandle,selected_child_index);
 292         Eina.Error.RaiseIfUnhandledException();
 293                         return _ret_var;
 294  }
 295     /// <summary>Adds selection for given child index</summary>
 296     /// <param name="child_index">Index of child</param>
 297     /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
 298     public bool ChildSelect(int child_index) {
 299                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_child_select_ptr.Value.Delegate(this.NativeHandle,child_index);
 300         Eina.Error.RaiseIfUnhandledException();
 301                         return _ret_var;
 302  }
 303     /// <summary>Removes selection for given child index</summary>
 304     /// <param name="child_index">Index of child</param>
 305     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 306     public bool SelectedChildDeselect(int child_index) {
 307                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_child_deselect_ptr.Value.Delegate(this.NativeHandle,child_index);
 308         Eina.Error.RaiseIfUnhandledException();
 309                         return _ret_var;
 310  }
 311     /// <summary>Determines if child specified by index is selected</summary>
 312     /// <param name="child_index">Index of child</param>
 313     /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
 314     public bool IsChildSelected(int child_index) {
 315                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_is_child_selected_ptr.Value.Delegate(this.NativeHandle,child_index);
 316         Eina.Error.RaiseIfUnhandledException();
 317                         return _ret_var;
 318  }
 319     /// <summary>Adds selection for all children</summary>
 320     /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
 321     public bool AllChildrenSelect() {
 322          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_all_children_select_ptr.Value.Delegate(this.NativeHandle);
 323         Eina.Error.RaiseIfUnhandledException();
 324         return _ret_var;
 325  }
 326     /// <summary>Clears the current selection</summary>
 327     /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
 328     public bool ClearAccessSelection() {
 329          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_clear_ptr.Value.Delegate(this.NativeHandle);
 330         Eina.Error.RaiseIfUnhandledException();
 331         return _ret_var;
 332  }
 333     /// <summary>Removes selection for given child index</summary>
 334     /// <param name="child_index">Index of child</param>
 335     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 336     public bool ChildDeselect(int child_index) {
 337                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_child_deselect_ptr.Value.Delegate(this.NativeHandle,child_index);
 338         Eina.Error.RaiseIfUnhandledException();
 339                         return _ret_var;
 340  }
 341     /// <summary>Gets the number of currently selected children</summary>
 342 /// <value>Number of currently selected children</value>
 343     public int SelectedChildrenCount {
 344         get { return GetSelectedChildrenCount(); }
 345     }
 346     private static IntPtr GetEflClassStatic()
 347     {
 348         return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 349     }
 350     /// <summary>Wrapper for native methods and virtual method delegates.
 351     /// For internal use by generated code only.</summary>
 352     public class NativeMethods  : Efl.Eo.NativeClass
 353     {
 354         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 355         /// <summary>Gets the list of Eo operations to override.</summary>
 356         /// <returns>The list of Eo operations to be overload.</returns>
 357         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 358         {
 359             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 360             var methods = Efl.Eo.Globals.GetUserMethods(type);
 361
 362             if (efl_access_selection_selected_children_count_get_static_delegate == null)
 363             {
 364                 efl_access_selection_selected_children_count_get_static_delegate = new efl_access_selection_selected_children_count_get_delegate(selected_children_count_get);
 365             }
 366
 367             if (methods.FirstOrDefault(m => m.Name == "GetSelectedChildrenCount") != null)
 368             {
 369                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_selected_children_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_selected_children_count_get_static_delegate) });
 370             }
 371
 372             if (efl_access_selection_selected_child_get_static_delegate == null)
 373             {
 374                 efl_access_selection_selected_child_get_static_delegate = new efl_access_selection_selected_child_get_delegate(selected_child_get);
 375             }
 376
 377             if (methods.FirstOrDefault(m => m.Name == "GetSelectedChild") != null)
 378             {
 379                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_selected_child_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_selected_child_get_static_delegate) });
 380             }
 381
 382             if (efl_access_selection_child_select_static_delegate == null)
 383             {
 384                 efl_access_selection_child_select_static_delegate = new efl_access_selection_child_select_delegate(child_select);
 385             }
 386
 387             if (methods.FirstOrDefault(m => m.Name == "ChildSelect") != null)
 388             {
 389                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_child_select"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_child_select_static_delegate) });
 390             }
 391
 392             if (efl_access_selection_selected_child_deselect_static_delegate == null)
 393             {
 394                 efl_access_selection_selected_child_deselect_static_delegate = new efl_access_selection_selected_child_deselect_delegate(selected_child_deselect);
 395             }
 396
 397             if (methods.FirstOrDefault(m => m.Name == "SelectedChildDeselect") != null)
 398             {
 399                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_selected_child_deselect"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_selected_child_deselect_static_delegate) });
 400             }
 401
 402             if (efl_access_selection_is_child_selected_static_delegate == null)
 403             {
 404                 efl_access_selection_is_child_selected_static_delegate = new efl_access_selection_is_child_selected_delegate(is_child_selected);
 405             }
 406
 407             if (methods.FirstOrDefault(m => m.Name == "IsChildSelected") != null)
 408             {
 409                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_is_child_selected"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_is_child_selected_static_delegate) });
 410             }
 411
 412             if (efl_access_selection_all_children_select_static_delegate == null)
 413             {
 414                 efl_access_selection_all_children_select_static_delegate = new efl_access_selection_all_children_select_delegate(all_children_select);
 415             }
 416
 417             if (methods.FirstOrDefault(m => m.Name == "AllChildrenSelect") != null)
 418             {
 419                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_all_children_select"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_all_children_select_static_delegate) });
 420             }
 421
 422             if (efl_access_selection_clear_static_delegate == null)
 423             {
 424                 efl_access_selection_clear_static_delegate = new efl_access_selection_clear_delegate(access_selection_clear);
 425             }
 426
 427             if (methods.FirstOrDefault(m => m.Name == "ClearAccessSelection") != null)
 428             {
 429                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_clear_static_delegate) });
 430             }
 431
 432             if (efl_access_selection_child_deselect_static_delegate == null)
 433             {
 434                 efl_access_selection_child_deselect_static_delegate = new efl_access_selection_child_deselect_delegate(child_deselect);
 435             }
 436
 437             if (methods.FirstOrDefault(m => m.Name == "ChildDeselect") != null)
 438             {
 439                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_selection_child_deselect"), func = Marshal.GetFunctionPointerForDelegate(efl_access_selection_child_deselect_static_delegate) });
 440             }
 441
 442             return descs;
 443         }
 444         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 445         /// <returns>The native class pointer.</returns>
 446         public override IntPtr GetEflClass()
 447         {
 448             return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 449         }
 450
 451         #pragma warning disable CA1707, SA1300, SA1600
 452
 453
 454         private delegate int efl_access_selection_selected_children_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 455
 456
 457         public delegate int efl_access_selection_selected_children_count_get_api_delegate(System.IntPtr obj);
 458
 459         public static Efl.Eo.FunctionWrapper<efl_access_selection_selected_children_count_get_api_delegate> efl_access_selection_selected_children_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_selected_children_count_get_api_delegate>(Module, "efl_access_selection_selected_children_count_get");
 460
 461         private static int selected_children_count_get(System.IntPtr obj, System.IntPtr pd)
 462         {
 463             Eina.Log.Debug("function efl_access_selection_selected_children_count_get was called");
 464             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 465             if (wrapper != null)
 466             {
 467             int _ret_var = default(int);
 468                 try
 469                 {
 470                     _ret_var = ((ISelection)wrapper).GetSelectedChildrenCount();
 471                 }
 472                 catch (Exception e)
 473                 {
 474                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 475                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 476                 }
 477
 478         return _ret_var;
 479
 480             }
 481             else
 482             {
 483                 return efl_access_selection_selected_children_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 484             }
 485         }
 486
 487         private static efl_access_selection_selected_children_count_get_delegate efl_access_selection_selected_children_count_get_static_delegate;
 488
 489         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 490         private delegate Efl.Object efl_access_selection_selected_child_get_delegate(System.IntPtr obj, System.IntPtr pd,  int selected_child_index);
 491
 492         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 493         public delegate Efl.Object efl_access_selection_selected_child_get_api_delegate(System.IntPtr obj,  int selected_child_index);
 494
 495         public static Efl.Eo.FunctionWrapper<efl_access_selection_selected_child_get_api_delegate> efl_access_selection_selected_child_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_selected_child_get_api_delegate>(Module, "efl_access_selection_selected_child_get");
 496
 497         private static Efl.Object selected_child_get(System.IntPtr obj, System.IntPtr pd, int selected_child_index)
 498         {
 499             Eina.Log.Debug("function efl_access_selection_selected_child_get was called");
 500             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 501             if (wrapper != null)
 502             {
 503                                     Efl.Object _ret_var = default(Efl.Object);
 504                 try
 505                 {
 506                     _ret_var = ((ISelection)wrapper).GetSelectedChild(selected_child_index);
 507                 }
 508                 catch (Exception e)
 509                 {
 510                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 511                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 512                 }
 513
 514                         return _ret_var;
 515
 516             }
 517             else
 518             {
 519                 return efl_access_selection_selected_child_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_child_index);
 520             }
 521         }
 522
 523         private static efl_access_selection_selected_child_get_delegate efl_access_selection_selected_child_get_static_delegate;
 524
 525         [return: MarshalAs(UnmanagedType.U1)]
 526         private delegate bool efl_access_selection_child_select_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 527
 528         [return: MarshalAs(UnmanagedType.U1)]
 529         public delegate bool efl_access_selection_child_select_api_delegate(System.IntPtr obj,  int child_index);
 530
 531         public static Efl.Eo.FunctionWrapper<efl_access_selection_child_select_api_delegate> efl_access_selection_child_select_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_child_select_api_delegate>(Module, "efl_access_selection_child_select");
 532
 533         private static bool child_select(System.IntPtr obj, System.IntPtr pd, int child_index)
 534         {
 535             Eina.Log.Debug("function efl_access_selection_child_select was called");
 536             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 537             if (wrapper != null)
 538             {
 539                                     bool _ret_var = default(bool);
 540                 try
 541                 {
 542                     _ret_var = ((ISelection)wrapper).ChildSelect(child_index);
 543                 }
 544                 catch (Exception e)
 545                 {
 546                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 547                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 548                 }
 549
 550                         return _ret_var;
 551
 552             }
 553             else
 554             {
 555                 return efl_access_selection_child_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 556             }
 557         }
 558
 559         private static efl_access_selection_child_select_delegate efl_access_selection_child_select_static_delegate;
 560
 561         [return: MarshalAs(UnmanagedType.U1)]
 562         private delegate bool efl_access_selection_selected_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 563
 564         [return: MarshalAs(UnmanagedType.U1)]
 565         public delegate bool efl_access_selection_selected_child_deselect_api_delegate(System.IntPtr obj,  int child_index);
 566
 567         public static Efl.Eo.FunctionWrapper<efl_access_selection_selected_child_deselect_api_delegate> efl_access_selection_selected_child_deselect_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_selected_child_deselect_api_delegate>(Module, "efl_access_selection_selected_child_deselect");
 568
 569         private static bool selected_child_deselect(System.IntPtr obj, System.IntPtr pd, int child_index)
 570         {
 571             Eina.Log.Debug("function efl_access_selection_selected_child_deselect was called");
 572             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 573             if (wrapper != null)
 574             {
 575                                     bool _ret_var = default(bool);
 576                 try
 577                 {
 578                     _ret_var = ((ISelection)wrapper).SelectedChildDeselect(child_index);
 579                 }
 580                 catch (Exception e)
 581                 {
 582                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 583                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 584                 }
 585
 586                         return _ret_var;
 587
 588             }
 589             else
 590             {
 591                 return efl_access_selection_selected_child_deselect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 592             }
 593         }
 594
 595         private static efl_access_selection_selected_child_deselect_delegate efl_access_selection_selected_child_deselect_static_delegate;
 596
 597         [return: MarshalAs(UnmanagedType.U1)]
 598         private delegate bool efl_access_selection_is_child_selected_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 599
 600         [return: MarshalAs(UnmanagedType.U1)]
 601         public delegate bool efl_access_selection_is_child_selected_api_delegate(System.IntPtr obj,  int child_index);
 602
 603         public static Efl.Eo.FunctionWrapper<efl_access_selection_is_child_selected_api_delegate> efl_access_selection_is_child_selected_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_is_child_selected_api_delegate>(Module, "efl_access_selection_is_child_selected");
 604
 605         private static bool is_child_selected(System.IntPtr obj, System.IntPtr pd, int child_index)
 606         {
 607             Eina.Log.Debug("function efl_access_selection_is_child_selected was called");
 608             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 609             if (wrapper != null)
 610             {
 611                                     bool _ret_var = default(bool);
 612                 try
 613                 {
 614                     _ret_var = ((ISelection)wrapper).IsChildSelected(child_index);
 615                 }
 616                 catch (Exception e)
 617                 {
 618                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 619                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 620                 }
 621
 622                         return _ret_var;
 623
 624             }
 625             else
 626             {
 627                 return efl_access_selection_is_child_selected_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 628             }
 629         }
 630
 631         private static efl_access_selection_is_child_selected_delegate efl_access_selection_is_child_selected_static_delegate;
 632
 633         [return: MarshalAs(UnmanagedType.U1)]
 634         private delegate bool efl_access_selection_all_children_select_delegate(System.IntPtr obj, System.IntPtr pd);
 635
 636         [return: MarshalAs(UnmanagedType.U1)]
 637         public delegate bool efl_access_selection_all_children_select_api_delegate(System.IntPtr obj);
 638
 639         public static Efl.Eo.FunctionWrapper<efl_access_selection_all_children_select_api_delegate> efl_access_selection_all_children_select_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_all_children_select_api_delegate>(Module, "efl_access_selection_all_children_select");
 640
 641         private static bool all_children_select(System.IntPtr obj, System.IntPtr pd)
 642         {
 643             Eina.Log.Debug("function efl_access_selection_all_children_select was called");
 644             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 645             if (wrapper != null)
 646             {
 647             bool _ret_var = default(bool);
 648                 try
 649                 {
 650                     _ret_var = ((ISelection)wrapper).AllChildrenSelect();
 651                 }
 652                 catch (Exception e)
 653                 {
 654                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 655                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 656                 }
 657
 658         return _ret_var;
 659
 660             }
 661             else
 662             {
 663                 return efl_access_selection_all_children_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 664             }
 665         }
 666
 667         private static efl_access_selection_all_children_select_delegate efl_access_selection_all_children_select_static_delegate;
 668
 669         [return: MarshalAs(UnmanagedType.U1)]
 670         private delegate bool efl_access_selection_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 671
 672         [return: MarshalAs(UnmanagedType.U1)]
 673         public delegate bool efl_access_selection_clear_api_delegate(System.IntPtr obj);
 674
 675         public static Efl.Eo.FunctionWrapper<efl_access_selection_clear_api_delegate> efl_access_selection_clear_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_clear_api_delegate>(Module, "efl_access_selection_clear");
 676
 677         private static bool access_selection_clear(System.IntPtr obj, System.IntPtr pd)
 678         {
 679             Eina.Log.Debug("function efl_access_selection_clear was called");
 680             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 681             if (wrapper != null)
 682             {
 683             bool _ret_var = default(bool);
 684                 try
 685                 {
 686                     _ret_var = ((ISelection)wrapper).ClearAccessSelection();
 687                 }
 688                 catch (Exception e)
 689                 {
 690                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 691                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 692                 }
 693
 694         return _ret_var;
 695
 696             }
 697             else
 698             {
 699                 return efl_access_selection_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 700             }
 701         }
 702
 703         private static efl_access_selection_clear_delegate efl_access_selection_clear_static_delegate;
 704
 705         [return: MarshalAs(UnmanagedType.U1)]
 706         private delegate bool efl_access_selection_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 707
 708         [return: MarshalAs(UnmanagedType.U1)]
 709         public delegate bool efl_access_selection_child_deselect_api_delegate(System.IntPtr obj,  int child_index);
 710
 711         public static Efl.Eo.FunctionWrapper<efl_access_selection_child_deselect_api_delegate> efl_access_selection_child_deselect_ptr = new Efl.Eo.FunctionWrapper<efl_access_selection_child_deselect_api_delegate>(Module, "efl_access_selection_child_deselect");
 712
 713         private static bool child_deselect(System.IntPtr obj, System.IntPtr pd, int child_index)
 714         {
 715             Eina.Log.Debug("function efl_access_selection_child_deselect was called");
 716             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 717             if (wrapper != null)
 718             {
 719                                     bool _ret_var = default(bool);
 720                 try
 721                 {
 722                     _ret_var = ((ISelection)wrapper).ChildDeselect(child_index);
 723                 }
 724                 catch (Exception e)
 725                 {
 726                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 727                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 728                 }
 729
 730                         return _ret_var;
 731
 732             }
 733             else
 734             {
 735                 return efl_access_selection_child_deselect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 736             }
 737         }
 738
 739         private static efl_access_selection_child_deselect_delegate efl_access_selection_child_deselect_static_delegate;
 740
 741         #pragma warning restore CA1707, SA1300, SA1600
 742
 743 }
 744 }
 745 }
 746
 747 }
 748