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

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