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.ComponentModel;
   7 namespace Efl { namespace Access {
   8 /// <summary>Elementary access selection interface</summary>
   9 [ISelectionNativeInherit]
  10 public interface ISelection :
  11     Efl.Eo.IWrapper, IDisposable
  12 {
  13     /// <summary>Gets the number of currently selected children</summary>
  14 /// <returns>Number of currently selected children</returns>
  15 int GetSelectedChildrenCount();
  16     /// <summary>Gets child for given child index</summary>
  17 /// <param name="selected_child_index">Index of child</param>
  18 /// <returns>Child object</returns>
  19 Efl.Object GetSelectedChild( int selected_child_index);
  20     /// <summary>Adds selection for given child index</summary>
  21 /// <param name="child_index">Index of child</param>
  22 /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
  23 bool ChildSelect( int child_index);
  24     /// <summary>Removes selection for given child index</summary>
  25 /// <param name="child_index">Index of child</param>
  26 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  27 bool SelectedChildDeselect( int child_index);
  28     /// <summary>Determines if child specified by index is selected</summary>
  29 /// <param name="child_index">Index of child</param>
  30 /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
  31 bool IsChildSelected( int child_index);
  32     /// <summary>Adds selection for all children</summary>
  33 /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
  34 bool AllChildrenSelect();
  35     /// <summary>Clears the current selection</summary>
  36 /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
  37 bool ClearAccessSelection();
  38     /// <summary>Removes selection for given child index</summary>
  39 /// <param name="child_index">Index of child</param>
  40 /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
  41 bool ChildDeselect( int child_index);
  42                                     /// <summary>Called when selection has been changed.</summary>
  43     event EventHandler AccessSelectionChangedEvt;
  44     /// <summary>Gets the number of currently selected children</summary>
  45 /// <value>Number of currently selected children</value>
  46     int SelectedChildrenCount {
  47         get ;
  48     }
  49 }
  50 /// <summary>Elementary access selection interface</summary>
  51 sealed public class ISelectionConcrete :
  52
  53 ISelection
  54
  55 {
  56     ///<summary>Pointer to the native class description.</summary>
  57     public System.IntPtr NativeClass {
  58         get {
  59             if (((object)this).GetType() == typeof (ISelectionConcrete))
  60                 return Efl.Access.ISelectionNativeInherit.GetEflClassStatic();
  61             else
  62                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  63         }
  64     }
  65     private EventHandlerList eventHandlers = new EventHandlerList();
  66     private  System.IntPtr handle;
  67     ///<summary>Pointer to the native instance.</summary>
  68     public System.IntPtr NativeHandle {
  69         get { return handle; }
  70     }
  71     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  72         efl_access_selection_interface_get();
  73     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  74     private ISelectionConcrete(System.IntPtr raw)
  75     {
  76         handle = raw;
  77         RegisterEventProxies();
  78     }
  79     ///<summary>Destructor.</summary>
  80     ~ISelectionConcrete()
  81     {
  82         Dispose(false);
  83     }
  84     ///<summary>Releases the underlying native instance.</summary>
  85     void Dispose(bool disposing)
  86     {
  87         if (handle != System.IntPtr.Zero) {
  88             Efl.Eo.Globals.efl_unref(handle);
  89             handle = System.IntPtr.Zero;
  90         }
  91     }
  92     ///<summary>Releases the underlying native instance.</summary>
  93     public void Dispose()
  94     {
  95         Dispose(true);
  96         GC.SuppressFinalize(this);
  97     }
  98     ///<summary>Verifies if the given object is equal to this one.</summary>
  99     public override bool Equals(object obj)
 100     {
 101         var other = obj as Efl.Object;
 102         if (other == null)
 103             return false;
 104         return this.NativeHandle == other.NativeHandle;
 105     }
 106     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 107     public override int GetHashCode()
 108     {
 109         return this.NativeHandle.ToInt32();
 110     }
 111     ///<summary>Turns the native pointer into a string representation.</summary>
 112     public override String ToString()
 113     {
 114         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 115     }
 116     private readonly object eventLock = new object();
 117     private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 118     ///<summary>Adds a new event handler, registering it to the native event. For internal use only.</summary>
 119     ///<param name="lib">The name of the native library definining the event.</param>
 120     ///<param name="key">The name of the native event.</param>
 121     ///<param name="evt_delegate">The delegate to be called on event raising.</param>
 122     ///<returns>True if the delegate was successfully registered.</returns>
 123     private bool AddNativeEventHandler(string lib, string key, Efl.EventCb evt_delegate) {
 124         int event_count = 0;
 125         if (!event_cb_count.TryGetValue(key, out event_count))
 126             event_cb_count[key] = event_count;
 127         if (event_count == 0) {
 128             IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 129             if (desc == IntPtr.Zero) {
 130                 Eina.Log.Error($"Failed to get native event {key}");
 131                 return false;
 132             }
 133              bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 134             if (!result) {
 135                 Eina.Log.Error($"Failed to add event proxy for event {key}");
 136                 return false;
 137             }
 138             Eina.Error.RaiseIfUnhandledException();
 139         }
 140         event_cb_count[key]++;
 141         return true;
 142     }
 143     ///<summary>Removes the given event handler for the given event. For internal use only.</summary>
 144     ///<param name="key">The name of the native event.</param>
 145     ///<param name="evt_delegate">The delegate to be removed.</param>
 146     ///<returns>True if the delegate was successfully registered.</returns>
 147     private bool RemoveNativeEventHandler(string key, Efl.EventCb evt_delegate) {
 148         int event_count = 0;
 149         if (!event_cb_count.TryGetValue(key, out event_count))
 150             event_cb_count[key] = event_count;
 151         if (event_count == 1) {
 152             IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 153             if (desc == IntPtr.Zero) {
 154                 Eina.Log.Error($"Failed to get native event {key}");
 155                 return false;
 156             }
 157             bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 158             if (!result) {
 159                 Eina.Log.Error($"Failed to remove event proxy for event {key}");
 160                 return false;
 161             }
 162             Eina.Error.RaiseIfUnhandledException();
 163         } else if (event_count == 0) {
 164             Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 165             return false;
 166         }
 167         event_cb_count[key]--;
 168         return true;
 169     }
 170 private static object AccessSelectionChangedEvtKey = new object();
 171     /// <summary>Called when selection has been changed.</summary>
 172     public event EventHandler AccessSelectionChangedEvt
 173     {
 174         add {
 175             lock (eventLock) {
 176                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 177                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_AccessSelectionChangedEvt_delegate)) {
 178                     eventHandlers.AddHandler(AccessSelectionChangedEvtKey , value);
 179                 } else
 180                     Eina.Log.Error($"Error adding proxy for event {key}");
 181             }
 182         }
 183         remove {
 184             lock (eventLock) {
 185                 string key = "_EFL_ACCESS_SELECTION_EVENT_ACCESS_SELECTION_CHANGED";
 186                 if (RemoveNativeEventHandler(key, this.evt_AccessSelectionChangedEvt_delegate)) {
 187                     eventHandlers.RemoveHandler(AccessSelectionChangedEvtKey , value);
 188                 } else
 189                     Eina.Log.Error($"Error removing proxy for event {key}");
 190             }
 191         }
 192     }
 193     ///<summary>Method to raise event AccessSelectionChangedEvt.</summary>
 194     public void On_AccessSelectionChangedEvt(EventArgs e)
 195     {
 196         EventHandler evt;
 197         lock (eventLock) {
 198         evt = (EventHandler)eventHandlers[AccessSelectionChangedEvtKey];
 199         }
 200         evt?.Invoke(this, e);
 201     }
 202     Efl.EventCb evt_AccessSelectionChangedEvt_delegate;
 203     private void on_AccessSelectionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 204     {
 205         EventArgs args = EventArgs.Empty;
 206         try {
 207             On_AccessSelectionChangedEvt(args);
 208         } catch (Exception e) {
 209             Eina.Log.Error(e.ToString());
 210             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 211         }
 212     }
 213
 214     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 215      void RegisterEventProxies()
 216     {
 217         evt_AccessSelectionChangedEvt_delegate = new Efl.EventCb(on_AccessSelectionChangedEvt_NativeCallback);
 218     }
 219     /// <summary>Gets the number of currently selected children</summary>
 220     /// <returns>Number of currently selected children</returns>
 221     public int GetSelectedChildrenCount() {
 222          var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_selected_children_count_get_ptr.Value.Delegate(this.NativeHandle);
 223         Eina.Error.RaiseIfUnhandledException();
 224         return _ret_var;
 225  }
 226     /// <summary>Gets child for given child index</summary>
 227     /// <param name="selected_child_index">Index of child</param>
 228     /// <returns>Child object</returns>
 229     public Efl.Object GetSelectedChild( int selected_child_index) {
 230                                  var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_selected_child_get_ptr.Value.Delegate(this.NativeHandle, selected_child_index);
 231         Eina.Error.RaiseIfUnhandledException();
 232                         return _ret_var;
 233  }
 234     /// <summary>Adds selection for given child index</summary>
 235     /// <param name="child_index">Index of child</param>
 236     /// <returns><c>true</c> if selection was added, <c>false</c> otherwise</returns>
 237     public bool ChildSelect( int child_index) {
 238                                  var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_child_select_ptr.Value.Delegate(this.NativeHandle, child_index);
 239         Eina.Error.RaiseIfUnhandledException();
 240                         return _ret_var;
 241  }
 242     /// <summary>Removes selection for given child index</summary>
 243     /// <param name="child_index">Index of child</param>
 244     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 245     public bool SelectedChildDeselect( int child_index) {
 246                                  var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_selected_child_deselect_ptr.Value.Delegate(this.NativeHandle, child_index);
 247         Eina.Error.RaiseIfUnhandledException();
 248                         return _ret_var;
 249  }
 250     /// <summary>Determines if child specified by index is selected</summary>
 251     /// <param name="child_index">Index of child</param>
 252     /// <returns><c>true</c> if child is selected, <c>false</c> otherwise</returns>
 253     public bool IsChildSelected( int child_index) {
 254                                  var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_is_child_selected_ptr.Value.Delegate(this.NativeHandle, child_index);
 255         Eina.Error.RaiseIfUnhandledException();
 256                         return _ret_var;
 257  }
 258     /// <summary>Adds selection for all children</summary>
 259     /// <returns><c>true</c> if selection was added to all children, <c>false</c> otherwise</returns>
 260     public bool AllChildrenSelect() {
 261          var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_all_children_select_ptr.Value.Delegate(this.NativeHandle);
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>Clears the current selection</summary>
 266     /// <returns><c>true</c> if selection was cleared, <c>false</c> otherwise</returns>
 267     public bool ClearAccessSelection() {
 268          var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_clear_ptr.Value.Delegate(this.NativeHandle);
 269         Eina.Error.RaiseIfUnhandledException();
 270         return _ret_var;
 271  }
 272     /// <summary>Removes selection for given child index</summary>
 273     /// <param name="child_index">Index of child</param>
 274     /// <returns><c>true</c> if selection was removed, <c>false</c> otherwise</returns>
 275     public bool ChildDeselect( int child_index) {
 276                                  var _ret_var = Efl.Access.ISelectionNativeInherit.efl_access_selection_child_deselect_ptr.Value.Delegate(this.NativeHandle, child_index);
 277         Eina.Error.RaiseIfUnhandledException();
 278                         return _ret_var;
 279  }
 280     /// <summary>Gets the number of currently selected children</summary>
 281 /// <value>Number of currently selected children</value>
 282     public int SelectedChildrenCount {
 283         get { return GetSelectedChildrenCount(); }
 284     }
 285     private static IntPtr GetEflClassStatic()
 286     {
 287         return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 288     }
 289 }
 290 public class ISelectionNativeInherit  : Efl.Eo.NativeClass{
 291     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 292     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 293     {
 294         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 295         var methods = Efl.Eo.Globals.GetUserMethods(type);
 296         if (efl_access_selection_selected_children_count_get_static_delegate == null)
 297             efl_access_selection_selected_children_count_get_static_delegate = new efl_access_selection_selected_children_count_get_delegate(selected_children_count_get);
 298         if (methods.FirstOrDefault(m => m.Name == "GetSelectedChildrenCount") != null)
 299             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)});
 300         if (efl_access_selection_selected_child_get_static_delegate == null)
 301             efl_access_selection_selected_child_get_static_delegate = new efl_access_selection_selected_child_get_delegate(selected_child_get);
 302         if (methods.FirstOrDefault(m => m.Name == "GetSelectedChild") != null)
 303             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)});
 304         if (efl_access_selection_child_select_static_delegate == null)
 305             efl_access_selection_child_select_static_delegate = new efl_access_selection_child_select_delegate(child_select);
 306         if (methods.FirstOrDefault(m => m.Name == "ChildSelect") != null)
 307             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)});
 308         if (efl_access_selection_selected_child_deselect_static_delegate == null)
 309             efl_access_selection_selected_child_deselect_static_delegate = new efl_access_selection_selected_child_deselect_delegate(selected_child_deselect);
 310         if (methods.FirstOrDefault(m => m.Name == "SelectedChildDeselect") != null)
 311             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)});
 312         if (efl_access_selection_is_child_selected_static_delegate == null)
 313             efl_access_selection_is_child_selected_static_delegate = new efl_access_selection_is_child_selected_delegate(is_child_selected);
 314         if (methods.FirstOrDefault(m => m.Name == "IsChildSelected") != null)
 315             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)});
 316         if (efl_access_selection_all_children_select_static_delegate == null)
 317             efl_access_selection_all_children_select_static_delegate = new efl_access_selection_all_children_select_delegate(all_children_select);
 318         if (methods.FirstOrDefault(m => m.Name == "AllChildrenSelect") != null)
 319             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)});
 320         if (efl_access_selection_clear_static_delegate == null)
 321             efl_access_selection_clear_static_delegate = new efl_access_selection_clear_delegate(access_selection_clear);
 322         if (methods.FirstOrDefault(m => m.Name == "ClearAccessSelection") != null)
 323             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)});
 324         if (efl_access_selection_child_deselect_static_delegate == null)
 325             efl_access_selection_child_deselect_static_delegate = new efl_access_selection_child_deselect_delegate(child_deselect);
 326         if (methods.FirstOrDefault(m => m.Name == "ChildDeselect") != null)
 327             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)});
 328         return descs;
 329     }
 330     public override IntPtr GetEflClass()
 331     {
 332         return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 333     }
 334     public static  IntPtr GetEflClassStatic()
 335     {
 336         return Efl.Access.ISelectionConcrete.efl_access_selection_interface_get();
 337     }
 338
 339
 340      private delegate int efl_access_selection_selected_children_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 341
 342
 343      public delegate int efl_access_selection_selected_children_count_get_api_delegate(System.IntPtr obj);
 344      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");
 345      private static int selected_children_count_get(System.IntPtr obj, System.IntPtr pd)
 346     {
 347         Eina.Log.Debug("function efl_access_selection_selected_children_count_get was called");
 348         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 349         if(wrapper != null) {
 350                         int _ret_var = default(int);
 351             try {
 352                 _ret_var = ((ISelection)wrapper).GetSelectedChildrenCount();
 353             } catch (Exception e) {
 354                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 355                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 356             }
 357         return _ret_var;
 358         } else {
 359             return efl_access_selection_selected_children_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 360         }
 361     }
 362     private static efl_access_selection_selected_children_count_get_delegate efl_access_selection_selected_children_count_get_static_delegate;
 363
 364
 365     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] private delegate Efl.Object efl_access_selection_selected_child_get_delegate(System.IntPtr obj, System.IntPtr pd,   int selected_child_index);
 366
 367
 368     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Object, Efl.Eo.NonOwnTag>))] public delegate Efl.Object efl_access_selection_selected_child_get_api_delegate(System.IntPtr obj,   int selected_child_index);
 369      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");
 370      private static Efl.Object selected_child_get(System.IntPtr obj, System.IntPtr pd,  int selected_child_index)
 371     {
 372         Eina.Log.Debug("function efl_access_selection_selected_child_get was called");
 373         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 374         if(wrapper != null) {
 375                                                 Efl.Object _ret_var = default(Efl.Object);
 376             try {
 377                 _ret_var = ((ISelection)wrapper).GetSelectedChild( selected_child_index);
 378             } catch (Exception e) {
 379                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 380                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 381             }
 382                         return _ret_var;
 383         } else {
 384             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);
 385         }
 386     }
 387     private static efl_access_selection_selected_child_get_delegate efl_access_selection_selected_child_get_static_delegate;
 388
 389
 390      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_child_select_delegate(System.IntPtr obj, System.IntPtr pd,   int child_index);
 391
 392
 393      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_child_select_api_delegate(System.IntPtr obj,   int child_index);
 394      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");
 395      private static bool child_select(System.IntPtr obj, System.IntPtr pd,  int child_index)
 396     {
 397         Eina.Log.Debug("function efl_access_selection_child_select was called");
 398         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 399         if(wrapper != null) {
 400                                                 bool _ret_var = default(bool);
 401             try {
 402                 _ret_var = ((ISelection)wrapper).ChildSelect( child_index);
 403             } catch (Exception e) {
 404                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 405                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 406             }
 407                         return _ret_var;
 408         } else {
 409             return efl_access_selection_child_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child_index);
 410         }
 411     }
 412     private static efl_access_selection_child_select_delegate efl_access_selection_child_select_static_delegate;
 413
 414
 415      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_selected_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,   int child_index);
 416
 417
 418      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_selected_child_deselect_api_delegate(System.IntPtr obj,   int child_index);
 419      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");
 420      private static bool selected_child_deselect(System.IntPtr obj, System.IntPtr pd,  int child_index)
 421     {
 422         Eina.Log.Debug("function efl_access_selection_selected_child_deselect was called");
 423         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 424         if(wrapper != null) {
 425                                                 bool _ret_var = default(bool);
 426             try {
 427                 _ret_var = ((ISelection)wrapper).SelectedChildDeselect( child_index);
 428             } catch (Exception e) {
 429                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 430                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 431             }
 432                         return _ret_var;
 433         } else {
 434             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);
 435         }
 436     }
 437     private static efl_access_selection_selected_child_deselect_delegate efl_access_selection_selected_child_deselect_static_delegate;
 438
 439
 440      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_is_child_selected_delegate(System.IntPtr obj, System.IntPtr pd,   int child_index);
 441
 442
 443      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_is_child_selected_api_delegate(System.IntPtr obj,   int child_index);
 444      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");
 445      private static bool is_child_selected(System.IntPtr obj, System.IntPtr pd,  int child_index)
 446     {
 447         Eina.Log.Debug("function efl_access_selection_is_child_selected was called");
 448         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 449         if(wrapper != null) {
 450                                                 bool _ret_var = default(bool);
 451             try {
 452                 _ret_var = ((ISelection)wrapper).IsChildSelected( child_index);
 453             } catch (Exception e) {
 454                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 455                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 456             }
 457                         return _ret_var;
 458         } else {
 459             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);
 460         }
 461     }
 462     private static efl_access_selection_is_child_selected_delegate efl_access_selection_is_child_selected_static_delegate;
 463
 464
 465      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_all_children_select_delegate(System.IntPtr obj, System.IntPtr pd);
 466
 467
 468      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_all_children_select_api_delegate(System.IntPtr obj);
 469      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");
 470      private static bool all_children_select(System.IntPtr obj, System.IntPtr pd)
 471     {
 472         Eina.Log.Debug("function efl_access_selection_all_children_select was called");
 473         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 474         if(wrapper != null) {
 475                         bool _ret_var = default(bool);
 476             try {
 477                 _ret_var = ((ISelection)wrapper).AllChildrenSelect();
 478             } catch (Exception e) {
 479                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 480                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 481             }
 482         return _ret_var;
 483         } else {
 484             return efl_access_selection_all_children_select_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 485         }
 486     }
 487     private static efl_access_selection_all_children_select_delegate efl_access_selection_all_children_select_static_delegate;
 488
 489
 490      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 491
 492
 493      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_clear_api_delegate(System.IntPtr obj);
 494      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");
 495      private static bool access_selection_clear(System.IntPtr obj, System.IntPtr pd)
 496     {
 497         Eina.Log.Debug("function efl_access_selection_clear was called");
 498         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 499         if(wrapper != null) {
 500                         bool _ret_var = default(bool);
 501             try {
 502                 _ret_var = ((ISelection)wrapper).ClearAccessSelection();
 503             } catch (Exception e) {
 504                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 505                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 506             }
 507         return _ret_var;
 508         } else {
 509             return efl_access_selection_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 510         }
 511     }
 512     private static efl_access_selection_clear_delegate efl_access_selection_clear_static_delegate;
 513
 514
 515      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_access_selection_child_deselect_delegate(System.IntPtr obj, System.IntPtr pd,   int child_index);
 516
 517
 518      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_access_selection_child_deselect_api_delegate(System.IntPtr obj,   int child_index);
 519      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");
 520      private static bool child_deselect(System.IntPtr obj, System.IntPtr pd,  int child_index)
 521     {
 522         Eina.Log.Debug("function efl_access_selection_child_deselect was called");
 523         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 524         if(wrapper != null) {
 525                                                 bool _ret_var = default(bool);
 526             try {
 527                 _ret_var = ((ISelection)wrapper).ChildDeselect( child_index);
 528             } catch (Exception e) {
 529                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 530                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 531             }
 532                         return _ret_var;
 533         } else {
 534             return efl_access_selection_child_deselect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  child_index);
 535         }
 536     }
 537     private static efl_access_selection_child_deselect_delegate efl_access_selection_child_deselect_static_delegate;
 538 }
 539 } }