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 [Efl.Eo.BindingEntity]
  15 public interface ISelection :
  16     Efl.Eo.IWrapper, IDisposable
  17 {
  18     /// <summary>Gets the number of currently selected children</summary>
  19 /// <returns>Number of currently selected children</returns>
  20 int GetSelectedChildrenCount();
  21     /// <summary>Gets child for given child index</summary>
  22 /// <param name="selected_child_index">Index of child</param>
  23 /// <returns>Child object</returns>
  24 Efl.Object GetSelectedChild(int selected_child_index);
  25     /// <summary>Adds selection for given child index</summary>
  26 /// <param name="child_index">Index of child</param>
  27 /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
  28 bool ChildSelect(int child_index);
  29     /// <summary>Removes selection for given child index</summary>
  30 /// <param name="child_index">Index of child</param>
  31 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  32 bool SelectedChildDeselect(int child_index);
  33     /// <summary>Determines if child specified by index is selected</summary>
  34 /// <param name="child_index">Index of child</param>
  35 /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
  36 bool IsChildSelected(int child_index);
  37     /// <summary>Adds selection for all children</summary>
  38 /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
  39 bool AllChildrenSelect();
  40     /// <summary>Clears the current selection</summary>
  41 /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
  42 bool ClearAccessSelection();
  43     /// <summary>Removes selection for given child index</summary>
  44 /// <param name="child_index">Index of child</param>
  45 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  46 bool ChildDeselect(int child_index);
  47                                     /// <summary>Called when selection has been changed.</summary>
  48     event EventHandler AccessSelectionChangedEvt;
  49     /// <summary>Gets the number of currently selected children</summary>
  50     /// <value>Number of currently selected children</value>
  51     int SelectedChildrenCount {
  52         get ;
  53     }
  54 }
  55 /// <summary>Elementary access selection interface</summary>
  56 sealed public class ISelectionConcrete :
  57     Efl.Eo.EoWrapper
  58     , ISelection
  59
  60 {
  61     ///<summary>Pointer to the native class description.</summary>
  62     public override System.IntPtr NativeClass
  63     {
  64         get
  65         {
  66             if (((object)this).GetType() == typeof(ISelectionConcrete))
  67             {
  68                 return GetEflClassStatic();
  69             }
  70             else
  71             {
  72                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  73             }
  74         }
  75     }
  76
  77     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  78     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  79     private ISelectionConcrete(ConstructingHandle ch) : base(ch)
  80     {
  81     }
  82
  83     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  84         efl_access_selection_interface_get();
  85     /// <summary>Initializes a new instance of the <see cref="ISelection"/> class.
  86     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  87     /// <param name="wh">The native pointer to be wrapped.</param>
  88     private ISelectionConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  89     {
  90     }
  91
  92     /// <summary>Called when selection has been changed.</summary>
  93     public event EventHandler AccessSelectionChangedEvt
  94     {
  95         add
  96         {
  97             lock (eflBindingEventLock)
  98             {
  99                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 100                 {
 101                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 102                     if (obj != null)
 103                     {
 104                         EventArgs args = EventArgs.Empty;
 105                         try
 106                         {
 107                             value?.Invoke(obj, args);
 108                         }
 109                         catch (Exception e)
 110                         {
 111                             Eina.Log.Error(e.ToString());
 112                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 113                         }
 114                     }
 115                 };
 116
 117                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 118                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 119             }
 120         }
 121
 122         remove
 123         {
 124             lock (eflBindingEventLock)
 125             {
 126                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 127                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 128             }
 129         }
 130     }
 131     ///<summary>Method to raise event AccessSelectionChangedEvt.</summary>
 132     public void OnAccessSelectionChangedEvt(EventArgs e)
 133     {
 134         var key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 135         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 136         if (desc == IntPtr.Zero)
 137         {
 138             Eina.Log.Error($"Failed to get native event {key}");
 139             return;
 140         }
 141
 142         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 143     }
 144     /// <summary>Gets the number of currently selected children</summary>
 145     /// <returns>Number of currently selected children</returns>
 146     public int GetSelectedChildrenCount() {
 147          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_children_count_get_ptr.Value.Delegate(this.NativeHandle);
 148         Eina.Error.RaiseIfUnhandledException();
 149         return _ret_var;
 150  }
 151     /// <summary>Gets child for given child index</summary>
 152     /// <param name="selected_child_index">Index of child</param>
 153     /// <returns>Child object</returns>
 154     public Efl.Object GetSelectedChild(int selected_child_index) {
 155                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_child_get_ptr.Value.Delegate(this.NativeHandle,selected_child_index);
 156         Eina.Error.RaiseIfUnhandledException();
 157                         return _ret_var;
 158  }
 159     /// <summary>Adds selection for given child index</summary>
 160     /// <param name="child_index">Index of child</param>
 161     /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
 162     public bool ChildSelect(int child_index) {
 163                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_child_select_ptr.Value.Delegate(this.NativeHandle,child_index);
 164         Eina.Error.RaiseIfUnhandledException();
 165                         return _ret_var;
 166  }
 167     /// <summary>Removes selection for given child index</summary>
 168     /// <param name="child_index">Index of child</param>
 169     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 170     public bool SelectedChildDeselect(int child_index) {
 171                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_selected_child_deselect_ptr.Value.Delegate(this.NativeHandle,child_index);
 172         Eina.Error.RaiseIfUnhandledException();
 173                         return _ret_var;
 174  }
 175     /// <summary>Determines if child specified by index is selected</summary>
 176     /// <param name="child_index">Index of child</param>
 177     /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
 178     public bool IsChildSelected(int child_index) {
 179                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_is_child_selected_ptr.Value.Delegate(this.NativeHandle,child_index);
 180         Eina.Error.RaiseIfUnhandledException();
 181                         return _ret_var;
 182  }
 183     /// <summary>Adds selection for all children</summary>
 184     /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
 185     public bool AllChildrenSelect() {
 186          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_all_children_select_ptr.Value.Delegate(this.NativeHandle);
 187         Eina.Error.RaiseIfUnhandledException();
 188         return _ret_var;
 189  }
 190     /// <summary>Clears the current selection</summary>
 191     /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
 192     public bool ClearAccessSelection() {
 193          var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_clear_ptr.Value.Delegate(this.NativeHandle);
 194         Eina.Error.RaiseIfUnhandledException();
 195         return _ret_var;
 196  }
 197     /// <summary>Removes selection for given child index</summary>
 198     /// <param name="child_index">Index of child</param>
 199     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 200     public bool ChildDeselect(int child_index) {
 201                                  var _ret_var = Efl.Access.ISelectionConcrete.NativeMethods.efl_access_selection_child_deselect_ptr.Value.Delegate(this.NativeHandle,child_index);
 202         Eina.Error.RaiseIfUnhandledException();
 203                         return _ret_var;
 204  }
 205     /// <summary>Gets the number of currently selected children</summary>
 206     /// <value>Number of currently selected children</value>
 207     public int SelectedChildrenCount {
 208         get { return GetSelectedChildrenCount(); }
 209     }
 210     private static IntPtr GetEflClassStatic()
 211     {
 212         return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 213     }
 214     /// <summary>Wrapper for native methods and virtual method delegates.
 215     /// For internal use by generated code only.</summary>
 216     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 217     {
 218         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 219         /// <summary>Gets the list of Eo operations to override.</summary>
 220         /// <returns>The list of Eo operations to be overload.</returns>
 221         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 222         {
 223             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 224             var methods = Efl.Eo.Globals.GetUserMethods(type);
 225
 226             if (efl_access_selection_selected_children_count_get_static_delegate == null)
 227             {
 228                 efl_access_selection_selected_children_count_get_static_delegate = new efl_access_selection_selected_children_count_get_delegate(selected_children_count_get);
 229             }
 230
 231             if (methods.FirstOrDefault(m => m.Name == "GetSelectedChildrenCount") != null)
 232             {
 233                 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) });
 234             }
 235
 236             if (efl_access_selection_selected_child_get_static_delegate == null)
 237             {
 238                 efl_access_selection_selected_child_get_static_delegate = new efl_access_selection_selected_child_get_delegate(selected_child_get);
 239             }
 240
 241             if (methods.FirstOrDefault(m => m.Name == "GetSelectedChild") != null)
 242             {
 243                 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) });
 244             }
 245
 246             if (efl_access_selection_child_select_static_delegate == null)
 247             {
 248                 efl_access_selection_child_select_static_delegate = new efl_access_selection_child_select_delegate(child_select);
 249             }
 250
 251             if (methods.FirstOrDefault(m => m.Name == "ChildSelect") != null)
 252             {
 253                 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) });
 254             }
 255
 256             if (efl_access_selection_selected_child_deselect_static_delegate == null)
 257             {
 258                 efl_access_selection_selected_child_deselect_static_delegate = new efl_access_selection_selected_child_deselect_delegate(selected_child_deselect);
 259             }
 260
 261             if (methods.FirstOrDefault(m => m.Name == "SelectedChildDeselect") != null)
 262             {
 263                 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) });
 264             }
 265
 266             if (efl_access_selection_is_child_selected_static_delegate == null)
 267             {
 268                 efl_access_selection_is_child_selected_static_delegate = new efl_access_selection_is_child_selected_delegate(is_child_selected);
 269             }
 270
 271             if (methods.FirstOrDefault(m => m.Name == "IsChildSelected") != null)
 272             {
 273                 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) });
 274             }
 275
 276             if (efl_access_selection_all_children_select_static_delegate == null)
 277             {
 278                 efl_access_selection_all_children_select_static_delegate = new efl_access_selection_all_children_select_delegate(all_children_select);
 279             }
 280
 281             if (methods.FirstOrDefault(m => m.Name == "AllChildrenSelect") != null)
 282             {
 283                 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) });
 284             }
 285
 286             if (efl_access_selection_clear_static_delegate == null)
 287             {
 288                 efl_access_selection_clear_static_delegate = new efl_access_selection_clear_delegate(access_selection_clear);
 289             }
 290
 291             if (methods.FirstOrDefault(m => m.Name == "ClearAccessSelection") != null)
 292             {
 293                 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) });
 294             }
 295
 296             if (efl_access_selection_child_deselect_static_delegate == null)
 297             {
 298                 efl_access_selection_child_deselect_static_delegate = new efl_access_selection_child_deselect_delegate(child_deselect);
 299             }
 300
 301             if (methods.FirstOrDefault(m => m.Name == "ChildDeselect") != null)
 302             {
 303                 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) });
 304             }
 305
 306             return descs;
 307         }
 308         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 309         /// <returns>The native class pointer.</returns>
 310         public override IntPtr GetEflClass()
 311         {
 312             return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 313         }
 314
 315         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 316
 317
 318         private delegate int efl_access_selection_selected_children_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 319
 320
 321         public delegate int efl_access_selection_selected_children_count_get_api_delegate(System.IntPtr obj);
 322
 323         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");
 324
 325         private static int selected_children_count_get(System.IntPtr obj, System.IntPtr pd)
 326         {
 327             Eina.Log.Debug("function efl_access_selection_selected_children_count_get was called");
 328             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 329             if (ws != null)
 330             {
 331             int _ret_var = default(int);
 332                 try
 333                 {
 334                     _ret_var = ((ISelection)ws.Target).GetSelectedChildrenCount();
 335                 }
 336                 catch (Exception e)
 337                 {
 338                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 339                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 340                 }
 341
 342         return _ret_var;
 343
 344             }
 345             else
 346             {
 347                 return efl_access_selection_selected_children_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 348             }
 349         }
 350
 351         private static efl_access_selection_selected_children_count_get_delegate efl_access_selection_selected_children_count_get_static_delegate;
 352
 353         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 354         private delegate Efl.Object efl_access_selection_selected_child_get_delegate(System.IntPtr obj, System.IntPtr pd,  int selected_child_index);
 355
 356         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 357         public delegate Efl.Object efl_access_selection_selected_child_get_api_delegate(System.IntPtr obj,  int selected_child_index);
 358
 359         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");
 360
 361         private static Efl.Object selected_child_get(System.IntPtr obj, System.IntPtr pd, int selected_child_index)
 362         {
 363             Eina.Log.Debug("function efl_access_selection_selected_child_get was called");
 364             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 365             if (ws != null)
 366             {
 367                                     Efl.Object _ret_var = default(Efl.Object);
 368                 try
 369                 {
 370                     _ret_var = ((ISelection)ws.Target).GetSelectedChild(selected_child_index);
 371                 }
 372                 catch (Exception e)
 373                 {
 374                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 375                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 376                 }
 377
 378                         return _ret_var;
 379
 380             }
 381             else
 382             {
 383                 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);
 384             }
 385         }
 386
 387         private static efl_access_selection_selected_child_get_delegate efl_access_selection_selected_child_get_static_delegate;
 388
 389         [return: MarshalAs(UnmanagedType.U1)]
 390         private delegate bool efl_access_selection_child_select_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 391
 392         [return: MarshalAs(UnmanagedType.U1)]
 393         public delegate bool efl_access_selection_child_select_api_delegate(System.IntPtr obj,  int child_index);
 394
 395         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");
 396
 397         private static bool child_select(System.IntPtr obj, System.IntPtr pd, int child_index)
 398         {
 399             Eina.Log.Debug("function efl_access_selection_child_select was called");
 400             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 401             if (ws != null)
 402             {
 403                                     bool _ret_var = default(bool);
 404                 try
 405                 {
 406                     _ret_var = ((ISelection)ws.Target).ChildSelect(child_index);
 407                 }
 408                 catch (Exception e)
 409                 {
 410                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 411                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 412                 }
 413
 414                         return _ret_var;
 415
 416             }
 417             else
 418             {
 419                 return efl_access_selection_child_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 420             }
 421         }
 422
 423         private static efl_access_selection_child_select_delegate efl_access_selection_child_select_static_delegate;
 424
 425         [return: MarshalAs(UnmanagedType.U1)]
 426         private delegate bool efl_access_selection_selected_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 427
 428         [return: MarshalAs(UnmanagedType.U1)]
 429         public delegate bool efl_access_selection_selected_child_deselect_api_delegate(System.IntPtr obj,  int child_index);
 430
 431         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");
 432
 433         private static bool selected_child_deselect(System.IntPtr obj, System.IntPtr pd, int child_index)
 434         {
 435             Eina.Log.Debug("function efl_access_selection_selected_child_deselect was called");
 436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 437             if (ws != null)
 438             {
 439                                     bool _ret_var = default(bool);
 440                 try
 441                 {
 442                     _ret_var = ((ISelection)ws.Target).SelectedChildDeselect(child_index);
 443                 }
 444                 catch (Exception e)
 445                 {
 446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 448                 }
 449
 450                         return _ret_var;
 451
 452             }
 453             else
 454             {
 455                 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);
 456             }
 457         }
 458
 459         private static efl_access_selection_selected_child_deselect_delegate efl_access_selection_selected_child_deselect_static_delegate;
 460
 461         [return: MarshalAs(UnmanagedType.U1)]
 462         private delegate bool efl_access_selection_is_child_selected_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 463
 464         [return: MarshalAs(UnmanagedType.U1)]
 465         public delegate bool efl_access_selection_is_child_selected_api_delegate(System.IntPtr obj,  int child_index);
 466
 467         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");
 468
 469         private static bool is_child_selected(System.IntPtr obj, System.IntPtr pd, int child_index)
 470         {
 471             Eina.Log.Debug("function efl_access_selection_is_child_selected was called");
 472             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 473             if (ws != null)
 474             {
 475                                     bool _ret_var = default(bool);
 476                 try
 477                 {
 478                     _ret_var = ((ISelection)ws.Target).IsChildSelected(child_index);
 479                 }
 480                 catch (Exception e)
 481                 {
 482                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 483                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 484                 }
 485
 486                         return _ret_var;
 487
 488             }
 489             else
 490             {
 491                 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);
 492             }
 493         }
 494
 495         private static efl_access_selection_is_child_selected_delegate efl_access_selection_is_child_selected_static_delegate;
 496
 497         [return: MarshalAs(UnmanagedType.U1)]
 498         private delegate bool efl_access_selection_all_children_select_delegate(System.IntPtr obj, System.IntPtr pd);
 499
 500         [return: MarshalAs(UnmanagedType.U1)]
 501         public delegate bool efl_access_selection_all_children_select_api_delegate(System.IntPtr obj);
 502
 503         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");
 504
 505         private static bool all_children_select(System.IntPtr obj, System.IntPtr pd)
 506         {
 507             Eina.Log.Debug("function efl_access_selection_all_children_select was called");
 508             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 509             if (ws != null)
 510             {
 511             bool _ret_var = default(bool);
 512                 try
 513                 {
 514                     _ret_var = ((ISelection)ws.Target).AllChildrenSelect();
 515                 }
 516                 catch (Exception e)
 517                 {
 518                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 519                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 520                 }
 521
 522         return _ret_var;
 523
 524             }
 525             else
 526             {
 527                 return efl_access_selection_all_children_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 528             }
 529         }
 530
 531         private static efl_access_selection_all_children_select_delegate efl_access_selection_all_children_select_static_delegate;
 532
 533         [return: MarshalAs(UnmanagedType.U1)]
 534         private delegate bool efl_access_selection_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 535
 536         [return: MarshalAs(UnmanagedType.U1)]
 537         public delegate bool efl_access_selection_clear_api_delegate(System.IntPtr obj);
 538
 539         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");
 540
 541         private static bool access_selection_clear(System.IntPtr obj, System.IntPtr pd)
 542         {
 543             Eina.Log.Debug("function efl_access_selection_clear was called");
 544             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 545             if (ws != null)
 546             {
 547             bool _ret_var = default(bool);
 548                 try
 549                 {
 550                     _ret_var = ((ISelection)ws.Target).ClearAccessSelection();
 551                 }
 552                 catch (Exception e)
 553                 {
 554                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 555                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 556                 }
 557
 558         return _ret_var;
 559
 560             }
 561             else
 562             {
 563                 return efl_access_selection_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 564             }
 565         }
 566
 567         private static efl_access_selection_clear_delegate efl_access_selection_clear_static_delegate;
 568
 569         [return: MarshalAs(UnmanagedType.U1)]
 570         private delegate bool efl_access_selection_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,  int child_index);
 571
 572         [return: MarshalAs(UnmanagedType.U1)]
 573         public delegate bool efl_access_selection_child_deselect_api_delegate(System.IntPtr obj,  int child_index);
 574
 575         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");
 576
 577         private static bool child_deselect(System.IntPtr obj, System.IntPtr pd, int child_index)
 578         {
 579             Eina.Log.Debug("function efl_access_selection_child_deselect was called");
 580             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 581             if (ws != null)
 582             {
 583                                     bool _ret_var = default(bool);
 584                 try
 585                 {
 586                     _ret_var = ((ISelection)ws.Target).ChildDeselect(child_index);
 587                 }
 588                 catch (Exception e)
 589                 {
 590                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 591                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 592                 }
 593
 594                         return _ret_var;
 595
 596             }
 597             else
 598             {
 599                 return efl_access_selection_child_deselect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child_index);
 600             }
 601         }
 602
 603         private static efl_access_selection_child_deselect_delegate efl_access_selection_child_deselect_static_delegate;
 604
 605         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 606
 607 }
 608 }
 609 }
 610
 611 }
 612