internals/src/EflSharp/EflSharp/efl/efl_ui_multi_selectable.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 Ui {
  12
  13 /// <summary>Interface for getting access to a range of selected items.
  14 /// The implementor of this interface provides the possibility to select multiple Selectables. (If not, only Efl.Ui.Single_Selectable should be implemented)</summary>
  15 /// <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>
  16 [Efl.Ui.IMultiSelectableConcrete.NativeMethods]
  17 [Efl.Eo.BindingEntity]
  18 public interface IMultiSelectable :
  19     Efl.Ui.ISingleSelectable ,
  20     Efl.Eo.IWrapper, IDisposable
  21 {
  22     /// <summary>The mode type for children selection.</summary>
  23 /// <returns>Type of selection of children</returns>
  24 Efl.Ui.SelectMode GetSelectMode();
  25     /// <summary>The mode type for children selection.</summary>
  26 /// <param name="mode">Type of selection of children</param>
  27 void SetSelectMode(Efl.Ui.SelectMode mode);
  28     /// <summary>Get the selected items in a iterator. The iterator sequence will be decided by selection.</summary>
  29 /// <returns>User has to free the iterator after usage.</returns>
  30 Eina.Iterator<Efl.Ui.ISelectable> GetSelectedItems();
  31     /// <summary>Select a range of <see cref="Efl.Ui.ISelectable"/>.
  32 /// This will select the range of selectables from a to b or from b to a depending on which one comes first. If a or b are not part of the widget, a error is returned, and no change is applied. <c>null</c> is not allowed as either of the parameters. Both of the passed values will also be selected.</summary>
  33 /// <param name="a">One side of the range.</param>
  34 /// <param name="b">The other side of the range.</param>
  35 void SelectRange(Efl.Ui.ISelectable a, Efl.Ui.ISelectable b);
  36     /// <summary>Unselect a range of <see cref="Efl.Ui.ISelectable"/>.
  37 /// This will unselect the range of selectables from a to b or from b to a depending on which one comes first. If a or b are not part of the widget, a error is returned, and no change is applied. <c>null</c> is not allowed as either of the parameters. Both of the passed values will also be unselected.</summary>
  38 /// <param name="a">One side of the range.</param>
  39 /// <param name="b">The other side of the range.</param>
  40 void UnselectRange(Efl.Ui.ISelectable a, Efl.Ui.ISelectable b);
  41     /// <summary>Select all <see cref="Efl.Ui.ISelectable"/></summary>
  42 void SelectAll();
  43     /// <summary>Unselect all <see cref="Efl.Ui.ISelectable"/></summary>
  44 void UnselectAll();
  45                                 /// <summary>The mode type for children selection.</summary>
  46     /// <value>Type of selection of children</value>
  47     Efl.Ui.SelectMode SelectMode {
  48         get;
  49         set;
  50     }
  51 }
  52 /// <summary>Interface for getting access to a range of selected items.
  53 /// The implementor of this interface provides the possibility to select multiple Selectables. (If not, only Efl.Ui.Single_Selectable should be implemented)</summary>
  54 /// <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>
  55 sealed public  class IMultiSelectableConcrete :
  56     Efl.Eo.EoWrapper
  57     , IMultiSelectable
  58     , Efl.Ui.ISingleSelectable
  59 {
  60     /// <summary>Pointer to the native class description.</summary>
  61     public override System.IntPtr NativeClass
  62     {
  63         get
  64         {
  65             if (((object)this).GetType() == typeof(IMultiSelectableConcrete))
  66             {
  67                 return GetEflClassStatic();
  68             }
  69             else
  70             {
  71                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  72             }
  73         }
  74     }
  75
  76     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  77     /// Do not call this constructor directly.</summary>
  78     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  79     private IMultiSelectableConcrete(ConstructingHandle ch) : base(ch)
  80     {
  81     }
  82
  83     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  84         efl_ui_multi_selectable_interface_get();
  85     /// <summary>Initializes a new instance of the <see cref="IMultiSelectable"/> 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 IMultiSelectableConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  89     {
  90     }
  91
  92     /// <summary>Called when there is a change in the selection state, this event will collect all the item selection change events that are happening within one loop iteration. This means, you will only get this event once, even if a lot of items have changed. If you are interested in detailed changes, subscribe to the selection,changed event of Efl.Ui.Selectable.</summary>
  93     public event EventHandler SelectionChangedEvt
  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_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED";
 118                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 119             }
 120         }
 121
 122         remove
 123         {
 124             lock (eflBindingEventLock)
 125             {
 126                 string key = "_EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED";
 127                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 128             }
 129         }
 130     }
 131     /// <summary>Method to raise event SelectionChangedEvt.</summary>
 132     public void OnSelectionChangedEvt(EventArgs e)
 133     {
 134         var key = "_EFL_UI_SINGLE_SELECTABLE_EVENT_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>The mode type for children selection.</summary>
 145     /// <returns>Type of selection of children</returns>
 146     public Efl.Ui.SelectMode GetSelectMode() {
 147          var _ret_var = Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_select_mode_get_ptr.Value.Delegate(this.NativeHandle);
 148         Eina.Error.RaiseIfUnhandledException();
 149         return _ret_var;
 150  }
 151     /// <summary>The mode type for children selection.</summary>
 152     /// <param name="mode">Type of selection of children</param>
 153     public void SetSelectMode(Efl.Ui.SelectMode mode) {
 154                                  Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_select_mode_set_ptr.Value.Delegate(this.NativeHandle,mode);
 155         Eina.Error.RaiseIfUnhandledException();
 156                          }
 157     /// <summary>Get the selected items in a iterator. The iterator sequence will be decided by selection.</summary>
 158     /// <returns>User has to free the iterator after usage.</returns>
 159     public Eina.Iterator<Efl.Ui.ISelectable> GetSelectedItems() {
 160          var _ret_var = Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_selected_items_get_ptr.Value.Delegate(this.NativeHandle);
 161         Eina.Error.RaiseIfUnhandledException();
 162         return new Eina.Iterator<Efl.Ui.ISelectable>(_ret_var, true);
 163  }
 164     /// <summary>Select a range of <see cref="Efl.Ui.ISelectable"/>.
 165     /// This will select the range of selectables from a to b or from b to a depending on which one comes first. If a or b are not part of the widget, a error is returned, and no change is applied. <c>null</c> is not allowed as either of the parameters. Both of the passed values will also be selected.</summary>
 166     /// <param name="a">One side of the range.</param>
 167     /// <param name="b">The other side of the range.</param>
 168     public void SelectRange(Efl.Ui.ISelectable a, Efl.Ui.ISelectable b) {
 169                                                          Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_select_range_ptr.Value.Delegate(this.NativeHandle,a, b);
 170         Eina.Error.RaiseIfUnhandledException();
 171                                          }
 172     /// <summary>Unselect a range of <see cref="Efl.Ui.ISelectable"/>.
 173     /// This will unselect the range of selectables from a to b or from b to a depending on which one comes first. If a or b are not part of the widget, a error is returned, and no change is applied. <c>null</c> is not allowed as either of the parameters. Both of the passed values will also be unselected.</summary>
 174     /// <param name="a">One side of the range.</param>
 175     /// <param name="b">The other side of the range.</param>
 176     public void UnselectRange(Efl.Ui.ISelectable a, Efl.Ui.ISelectable b) {
 177                                                          Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_unselect_range_ptr.Value.Delegate(this.NativeHandle,a, b);
 178         Eina.Error.RaiseIfUnhandledException();
 179                                          }
 180     /// <summary>Select all <see cref="Efl.Ui.ISelectable"/></summary>
 181     public void SelectAll() {
 182          Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_select_all_ptr.Value.Delegate(this.NativeHandle);
 183         Eina.Error.RaiseIfUnhandledException();
 184          }
 185     /// <summary>Unselect all <see cref="Efl.Ui.ISelectable"/></summary>
 186     public void UnselectAll() {
 187          Efl.Ui.IMultiSelectableConcrete.NativeMethods.efl_ui_unselect_all_ptr.Value.Delegate(this.NativeHandle);
 188         Eina.Error.RaiseIfUnhandledException();
 189          }
 190     /// <summary>The selectable that was selected most recently.</summary>
 191     /// <returns>The latest selected item.</returns>
 192     public Efl.Ui.ISelectable GetLastSelected() {
 193          var _ret_var = Efl.Ui.ISingleSelectableConcrete.NativeMethods.efl_ui_single_selectable_last_selected_get_ptr.Value.Delegate(this.NativeHandle);
 194         Eina.Error.RaiseIfUnhandledException();
 195         return _ret_var;
 196  }
 197     /// <summary>A object that will be selected in case nothing is selected
 198     /// A object set to this property will be selected instead of no item beeing selected. Which means, there will be always at least one element selected. If this property is NULL, the state of &quot;no item is selected&quot; can be reached.
 199     ///
 200     /// Setting this property as a result of selection events results in undefined behavior.</summary>
 201     public Efl.Ui.ISelectable GetFallbackSelection() {
 202          var _ret_var = Efl.Ui.ISingleSelectableConcrete.NativeMethods.efl_ui_single_selectable_fallback_selection_get_ptr.Value.Delegate(this.NativeHandle);
 203         Eina.Error.RaiseIfUnhandledException();
 204         return _ret_var;
 205  }
 206     /// <summary>A object that will be selected in case nothing is selected
 207     /// A object set to this property will be selected instead of no item beeing selected. Which means, there will be always at least one element selected. If this property is NULL, the state of &quot;no item is selected&quot; can be reached.
 208     ///
 209     /// Setting this property as a result of selection events results in undefined behavior.</summary>
 210     public void SetFallbackSelection(Efl.Ui.ISelectable fallback) {
 211                                  Efl.Ui.ISingleSelectableConcrete.NativeMethods.efl_ui_single_selectable_fallback_selection_set_ptr.Value.Delegate(this.NativeHandle,fallback);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <summary>The mode type for children selection.</summary>
 215     /// <value>Type of selection of children</value>
 216     public Efl.Ui.SelectMode SelectMode {
 217         get { return GetSelectMode(); }
 218         set { SetSelectMode(value); }
 219     }
 220     /// <summary>The selectable that was selected most recently.</summary>
 221     /// <value>The latest selected item.</value>
 222     public Efl.Ui.ISelectable LastSelected {
 223         get { return GetLastSelected(); }
 224     }
 225     /// <summary>A object that will be selected in case nothing is selected
 226     /// A object set to this property will be selected instead of no item beeing selected. Which means, there will be always at least one element selected. If this property is NULL, the state of &quot;no item is selected&quot; can be reached.
 227     ///
 228     /// Setting this property as a result of selection events results in undefined behavior.</summary>
 229     public Efl.Ui.ISelectable FallbackSelection {
 230         get { return GetFallbackSelection(); }
 231         set { SetFallbackSelection(value); }
 232     }
 233     private static IntPtr GetEflClassStatic()
 234     {
 235         return Efl.Ui.IMultiSelectableConcrete.efl_ui_multi_selectable_interface_get();
 236     }
 237     /// <summary>Wrapper for native methods and virtual method delegates.
 238     /// For internal use by generated code only.</summary>
 239     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 240     {
 241         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 242         /// <summary>Gets the list of Eo operations to override.</summary>
 243         /// <returns>The list of Eo operations to be overload.</returns>
 244         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 245         {
 246             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 247             var methods = Efl.Eo.Globals.GetUserMethods(type);
 248
 249             if (efl_ui_select_mode_get_static_delegate == null)
 250             {
 251                 efl_ui_select_mode_get_static_delegate = new efl_ui_select_mode_get_delegate(select_mode_get);
 252             }
 253
 254             if (methods.FirstOrDefault(m => m.Name == "GetSelectMode") != null)
 255             {
 256                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_select_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_mode_get_static_delegate) });
 257             }
 258
 259             if (efl_ui_select_mode_set_static_delegate == null)
 260             {
 261                 efl_ui_select_mode_set_static_delegate = new efl_ui_select_mode_set_delegate(select_mode_set);
 262             }
 263
 264             if (methods.FirstOrDefault(m => m.Name == "SetSelectMode") != null)
 265             {
 266                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_select_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_mode_set_static_delegate) });
 267             }
 268
 269             if (efl_ui_selected_items_get_static_delegate == null)
 270             {
 271                 efl_ui_selected_items_get_static_delegate = new efl_ui_selected_items_get_delegate(selected_items_get);
 272             }
 273
 274             if (methods.FirstOrDefault(m => m.Name == "GetSelectedItems") != null)
 275             {
 276                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_selected_items_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_selected_items_get_static_delegate) });
 277             }
 278
 279             if (efl_ui_select_range_static_delegate == null)
 280             {
 281                 efl_ui_select_range_static_delegate = new efl_ui_select_range_delegate(select_range);
 282             }
 283
 284             if (methods.FirstOrDefault(m => m.Name == "SelectRange") != null)
 285             {
 286                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_select_range"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_range_static_delegate) });
 287             }
 288
 289             if (efl_ui_unselect_range_static_delegate == null)
 290             {
 291                 efl_ui_unselect_range_static_delegate = new efl_ui_unselect_range_delegate(unselect_range);
 292             }
 293
 294             if (methods.FirstOrDefault(m => m.Name == "UnselectRange") != null)
 295             {
 296                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_unselect_range"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_unselect_range_static_delegate) });
 297             }
 298
 299             if (efl_ui_select_all_static_delegate == null)
 300             {
 301                 efl_ui_select_all_static_delegate = new efl_ui_select_all_delegate(select_all);
 302             }
 303
 304             if (methods.FirstOrDefault(m => m.Name == "SelectAll") != null)
 305             {
 306                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_select_all"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_all_static_delegate) });
 307             }
 308
 309             if (efl_ui_unselect_all_static_delegate == null)
 310             {
 311                 efl_ui_unselect_all_static_delegate = new efl_ui_unselect_all_delegate(unselect_all);
 312             }
 313
 314             if (methods.FirstOrDefault(m => m.Name == "UnselectAll") != null)
 315             {
 316                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_unselect_all"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_unselect_all_static_delegate) });
 317             }
 318
 319             if (efl_ui_single_selectable_last_selected_get_static_delegate == null)
 320             {
 321                 efl_ui_single_selectable_last_selected_get_static_delegate = new efl_ui_single_selectable_last_selected_get_delegate(last_selected_get);
 322             }
 323
 324             if (methods.FirstOrDefault(m => m.Name == "GetLastSelected") != null)
 325             {
 326                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_single_selectable_last_selected_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_single_selectable_last_selected_get_static_delegate) });
 327             }
 328
 329             if (efl_ui_single_selectable_fallback_selection_get_static_delegate == null)
 330             {
 331                 efl_ui_single_selectable_fallback_selection_get_static_delegate = new efl_ui_single_selectable_fallback_selection_get_delegate(fallback_selection_get);
 332             }
 333
 334             if (methods.FirstOrDefault(m => m.Name == "GetFallbackSelection") != null)
 335             {
 336                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_single_selectable_fallback_selection_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_single_selectable_fallback_selection_get_static_delegate) });
 337             }
 338
 339             if (efl_ui_single_selectable_fallback_selection_set_static_delegate == null)
 340             {
 341                 efl_ui_single_selectable_fallback_selection_set_static_delegate = new efl_ui_single_selectable_fallback_selection_set_delegate(fallback_selection_set);
 342             }
 343
 344             if (methods.FirstOrDefault(m => m.Name == "SetFallbackSelection") != null)
 345             {
 346                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_single_selectable_fallback_selection_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_single_selectable_fallback_selection_set_static_delegate) });
 347             }
 348
 349             return descs;
 350         }
 351         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 352         /// <returns>The native class pointer.</returns>
 353         public override IntPtr GetEflClass()
 354         {
 355             return Efl.Ui.IMultiSelectableConcrete.efl_ui_multi_selectable_interface_get();
 356         }
 357
 358         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 359
 360
 361         private delegate Efl.Ui.SelectMode efl_ui_select_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 362
 363
 364         public delegate Efl.Ui.SelectMode efl_ui_select_mode_get_api_delegate(System.IntPtr obj);
 365
 366         public static Efl.Eo.FunctionWrapper<efl_ui_select_mode_get_api_delegate> efl_ui_select_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_mode_get_api_delegate>(Module, "efl_ui_select_mode_get");
 367
 368         private static Efl.Ui.SelectMode select_mode_get(System.IntPtr obj, System.IntPtr pd)
 369         {
 370             Eina.Log.Debug("function efl_ui_select_mode_get was called");
 371             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 372             if (ws != null)
 373             {
 374             Efl.Ui.SelectMode _ret_var = default(Efl.Ui.SelectMode);
 375                 try
 376                 {
 377                     _ret_var = ((IMultiSelectable)ws.Target).GetSelectMode();
 378                 }
 379                 catch (Exception e)
 380                 {
 381                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 382                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 383                 }
 384
 385         return _ret_var;
 386
 387             }
 388             else
 389             {
 390                 return efl_ui_select_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 391             }
 392         }
 393
 394         private static efl_ui_select_mode_get_delegate efl_ui_select_mode_get_static_delegate;
 395
 396
 397         private delegate void efl_ui_select_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectMode mode);
 398
 399
 400         public delegate void efl_ui_select_mode_set_api_delegate(System.IntPtr obj,  Efl.Ui.SelectMode mode);
 401
 402         public static Efl.Eo.FunctionWrapper<efl_ui_select_mode_set_api_delegate> efl_ui_select_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_mode_set_api_delegate>(Module, "efl_ui_select_mode_set");
 403
 404         private static void select_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.SelectMode mode)
 405         {
 406             Eina.Log.Debug("function efl_ui_select_mode_set was called");
 407             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 408             if (ws != null)
 409             {
 410
 411                 try
 412                 {
 413                     ((IMultiSelectable)ws.Target).SetSelectMode(mode);
 414                 }
 415                 catch (Exception e)
 416                 {
 417                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 418                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 419                 }
 420
 421
 422             }
 423             else
 424             {
 425                 efl_ui_select_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode);
 426             }
 427         }
 428
 429         private static efl_ui_select_mode_set_delegate efl_ui_select_mode_set_static_delegate;
 430
 431
 432         private delegate System.IntPtr efl_ui_selected_items_get_delegate(System.IntPtr obj, System.IntPtr pd);
 433
 434
 435         public delegate System.IntPtr efl_ui_selected_items_get_api_delegate(System.IntPtr obj);
 436
 437         public static Efl.Eo.FunctionWrapper<efl_ui_selected_items_get_api_delegate> efl_ui_selected_items_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_selected_items_get_api_delegate>(Module, "efl_ui_selected_items_get");
 438
 439         private static System.IntPtr selected_items_get(System.IntPtr obj, System.IntPtr pd)
 440         {
 441             Eina.Log.Debug("function efl_ui_selected_items_get was called");
 442             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 443             if (ws != null)
 444             {
 445             Eina.Iterator<Efl.Ui.ISelectable> _ret_var = default(Eina.Iterator<Efl.Ui.ISelectable>);
 446                 try
 447                 {
 448                     _ret_var = ((IMultiSelectable)ws.Target).GetSelectedItems();
 449                 }
 450                 catch (Exception e)
 451                 {
 452                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 453                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 454                 }
 455
 456         _ret_var.Own = false; return _ret_var.Handle;
 457
 458             }
 459             else
 460             {
 461                 return efl_ui_selected_items_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 462             }
 463         }
 464
 465         private static efl_ui_selected_items_get_delegate efl_ui_selected_items_get_static_delegate;
 466
 467
 468         private delegate void efl_ui_select_range_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable a, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable b);
 469
 470
 471         public delegate void efl_ui_select_range_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable a, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable b);
 472
 473         public static Efl.Eo.FunctionWrapper<efl_ui_select_range_api_delegate> efl_ui_select_range_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_range_api_delegate>(Module, "efl_ui_select_range");
 474
 475         private static void select_range(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ISelectable a, Efl.Ui.ISelectable b)
 476         {
 477             Eina.Log.Debug("function efl_ui_select_range was called");
 478             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 479             if (ws != null)
 480             {
 481
 482                 try
 483                 {
 484                     ((IMultiSelectable)ws.Target).SelectRange(a, b);
 485                 }
 486                 catch (Exception e)
 487                 {
 488                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 489                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 490                 }
 491
 492
 493             }
 494             else
 495             {
 496                 efl_ui_select_range_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), a, b);
 497             }
 498         }
 499
 500         private static efl_ui_select_range_delegate efl_ui_select_range_static_delegate;
 501
 502
 503         private delegate void efl_ui_unselect_range_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable a, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable b);
 504
 505
 506         public delegate void efl_ui_unselect_range_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable a, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable b);
 507
 508         public static Efl.Eo.FunctionWrapper<efl_ui_unselect_range_api_delegate> efl_ui_unselect_range_ptr = new Efl.Eo.FunctionWrapper<efl_ui_unselect_range_api_delegate>(Module, "efl_ui_unselect_range");
 509
 510         private static void unselect_range(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ISelectable a, Efl.Ui.ISelectable b)
 511         {
 512             Eina.Log.Debug("function efl_ui_unselect_range was called");
 513             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 514             if (ws != null)
 515             {
 516
 517                 try
 518                 {
 519                     ((IMultiSelectable)ws.Target).UnselectRange(a, b);
 520                 }
 521                 catch (Exception e)
 522                 {
 523                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 524                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 525                 }
 526
 527
 528             }
 529             else
 530             {
 531                 efl_ui_unselect_range_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), a, b);
 532             }
 533         }
 534
 535         private static efl_ui_unselect_range_delegate efl_ui_unselect_range_static_delegate;
 536
 537
 538         private delegate void efl_ui_select_all_delegate(System.IntPtr obj, System.IntPtr pd);
 539
 540
 541         public delegate void efl_ui_select_all_api_delegate(System.IntPtr obj);
 542
 543         public static Efl.Eo.FunctionWrapper<efl_ui_select_all_api_delegate> efl_ui_select_all_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_all_api_delegate>(Module, "efl_ui_select_all");
 544
 545         private static void select_all(System.IntPtr obj, System.IntPtr pd)
 546         {
 547             Eina.Log.Debug("function efl_ui_select_all was called");
 548             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 549             if (ws != null)
 550             {
 551
 552                 try
 553                 {
 554                     ((IMultiSelectable)ws.Target).SelectAll();
 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
 563             }
 564             else
 565             {
 566                 efl_ui_select_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 567             }
 568         }
 569
 570         private static efl_ui_select_all_delegate efl_ui_select_all_static_delegate;
 571
 572
 573         private delegate void efl_ui_unselect_all_delegate(System.IntPtr obj, System.IntPtr pd);
 574
 575
 576         public delegate void efl_ui_unselect_all_api_delegate(System.IntPtr obj);
 577
 578         public static Efl.Eo.FunctionWrapper<efl_ui_unselect_all_api_delegate> efl_ui_unselect_all_ptr = new Efl.Eo.FunctionWrapper<efl_ui_unselect_all_api_delegate>(Module, "efl_ui_unselect_all");
 579
 580         private static void unselect_all(System.IntPtr obj, System.IntPtr pd)
 581         {
 582             Eina.Log.Debug("function efl_ui_unselect_all was called");
 583             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 584             if (ws != null)
 585             {
 586
 587                 try
 588                 {
 589                     ((IMultiSelectable)ws.Target).UnselectAll();
 590                 }
 591                 catch (Exception e)
 592                 {
 593                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 594                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 595                 }
 596
 597
 598             }
 599             else
 600             {
 601                 efl_ui_unselect_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 602             }
 603         }
 604
 605         private static efl_ui_unselect_all_delegate efl_ui_unselect_all_static_delegate;
 606
 607         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 608         private delegate Efl.Ui.ISelectable efl_ui_single_selectable_last_selected_get_delegate(System.IntPtr obj, System.IntPtr pd);
 609
 610         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 611         public delegate Efl.Ui.ISelectable efl_ui_single_selectable_last_selected_get_api_delegate(System.IntPtr obj);
 612
 613         public static Efl.Eo.FunctionWrapper<efl_ui_single_selectable_last_selected_get_api_delegate> efl_ui_single_selectable_last_selected_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_single_selectable_last_selected_get_api_delegate>(Module, "efl_ui_single_selectable_last_selected_get");
 614
 615         private static Efl.Ui.ISelectable last_selected_get(System.IntPtr obj, System.IntPtr pd)
 616         {
 617             Eina.Log.Debug("function efl_ui_single_selectable_last_selected_get was called");
 618             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 619             if (ws != null)
 620             {
 621             Efl.Ui.ISelectable _ret_var = default(Efl.Ui.ISelectable);
 622                 try
 623                 {
 624                     _ret_var = ((IMultiSelectable)ws.Target).GetLastSelected();
 625                 }
 626                 catch (Exception e)
 627                 {
 628                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 629                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 630                 }
 631
 632         return _ret_var;
 633
 634             }
 635             else
 636             {
 637                 return efl_ui_single_selectable_last_selected_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 638             }
 639         }
 640
 641         private static efl_ui_single_selectable_last_selected_get_delegate efl_ui_single_selectable_last_selected_get_static_delegate;
 642
 643         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 644         private delegate Efl.Ui.ISelectable efl_ui_single_selectable_fallback_selection_get_delegate(System.IntPtr obj, System.IntPtr pd);
 645
 646         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 647         public delegate Efl.Ui.ISelectable efl_ui_single_selectable_fallback_selection_get_api_delegate(System.IntPtr obj);
 648
 649         public static Efl.Eo.FunctionWrapper<efl_ui_single_selectable_fallback_selection_get_api_delegate> efl_ui_single_selectable_fallback_selection_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_single_selectable_fallback_selection_get_api_delegate>(Module, "efl_ui_single_selectable_fallback_selection_get");
 650
 651         private static Efl.Ui.ISelectable fallback_selection_get(System.IntPtr obj, System.IntPtr pd)
 652         {
 653             Eina.Log.Debug("function efl_ui_single_selectable_fallback_selection_get was called");
 654             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 655             if (ws != null)
 656             {
 657             Efl.Ui.ISelectable _ret_var = default(Efl.Ui.ISelectable);
 658                 try
 659                 {
 660                     _ret_var = ((IMultiSelectable)ws.Target).GetFallbackSelection();
 661                 }
 662                 catch (Exception e)
 663                 {
 664                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 665                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 666                 }
 667
 668         return _ret_var;
 669
 670             }
 671             else
 672             {
 673                 return efl_ui_single_selectable_fallback_selection_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 674             }
 675         }
 676
 677         private static efl_ui_single_selectable_fallback_selection_get_delegate efl_ui_single_selectable_fallback_selection_get_static_delegate;
 678
 679
 680         private delegate void efl_ui_single_selectable_fallback_selection_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable fallback);
 681
 682
 683         public delegate void efl_ui_single_selectable_fallback_selection_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.ISelectable fallback);
 684
 685         public static Efl.Eo.FunctionWrapper<efl_ui_single_selectable_fallback_selection_set_api_delegate> efl_ui_single_selectable_fallback_selection_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_single_selectable_fallback_selection_set_api_delegate>(Module, "efl_ui_single_selectable_fallback_selection_set");
 686
 687         private static void fallback_selection_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ISelectable fallback)
 688         {
 689             Eina.Log.Debug("function efl_ui_single_selectable_fallback_selection_set was called");
 690             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 691             if (ws != null)
 692             {
 693
 694                 try
 695                 {
 696                     ((IMultiSelectable)ws.Target).SetFallbackSelection(fallback);
 697                 }
 698                 catch (Exception e)
 699                 {
 700                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 701                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 702                 }
 703
 704
 705             }
 706             else
 707             {
 708                 efl_ui_single_selectable_fallback_selection_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fallback);
 709             }
 710         }
 711
 712         private static efl_ui_single_selectable_fallback_selection_set_delegate efl_ui_single_selectable_fallback_selection_set_static_delegate;
 713
 714         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 715
 716 }
 717 }
 718 }
 719
 720 }
 721
 722 #if EFL_BETA
 723 #pragma warning disable CS1591
 724 public static class Efl_UiIMultiSelectableConcrete_ExtensionMethods {
 725     public static Efl.BindableProperty<Efl.Ui.SelectMode> SelectMode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IMultiSelectable, T>magic = null) where T : Efl.Ui.IMultiSelectable {
 726         return new Efl.BindableProperty<Efl.Ui.SelectMode>("select_mode", fac);
 727     }
 728
 729
 730     public static Efl.BindableProperty<Efl.Ui.ISelectable> FallbackSelection<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IMultiSelectable, T>magic = null) where T : Efl.Ui.IMultiSelectable {
 731         return new Efl.BindableProperty<Efl.Ui.ISelectable>("fallback_selection", fac);
 732     }
 733
 734 }
 735 #pragma warning restore CS1591
 736 #endif
 737 namespace Efl {
 738
 739 namespace Ui {
 740
 741 /// <summary>Type of multi selectable object.</summary>
 742 [Efl.Eo.BindingEntity]
 743 public enum SelectMode
 744 {
 745 /// <summary>Only single child is selected. if the child is selected, previous selected child will be unselected.</summary>
 746 Single = 0,
 747 /// <summary>Same as single select except, this will be selected in every select calls though child is already been selected.</summary>
 748 SingleAlways = 1,
 749 /// <summary>allow multiple selection of children.</summary>
 750 Multi = 2,
 751 /// <summary>Last value of select mode. child cannot be selected at all.</summary>
 752 None = 3,
 753 }
 754
 755 }
 756
 757 }
 758