internals/src/EflSharp/EflSharp/efl/efl_select_model.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 /// <summary>Event argument wrapper for event <see cref="Efl.SelectModel.SelectedEvt"/>.</summary>
  12 [Efl.Eo.BindingEntity]
  13 public class SelectModelSelectedEvt_Args : EventArgs {
  14     /// <summary>Actual event payload.</summary>
  15     /// <value></value>
  16     public Efl.Object arg { get; set; }
  17 }
  18 /// <summary>Event argument wrapper for event <see cref="Efl.SelectModel.UnselectedEvt"/>.</summary>
  19 [Efl.Eo.BindingEntity]
  20 public class SelectModelUnselectedEvt_Args : EventArgs {
  21     /// <summary>Actual event payload.</summary>
  22     /// <value></value>
  23     public Efl.Object arg { get; set; }
  24 }
  25 /// <summary>Efl select model class</summary>
  26 /// <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>
  27 [Efl.SelectModel.NativeMethods]
  28 [Efl.Eo.BindingEntity]
  29 public class SelectModel : Efl.BooleanModel
  30 {
  31     /// <summary>Pointer to the native class description.</summary>
  32     public override System.IntPtr NativeClass
  33     {
  34         get
  35         {
  36             if (((object)this).GetType() == typeof(SelectModel))
  37             {
  38                 return GetEflClassStatic();
  39             }
  40             else
  41             {
  42                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  43             }
  44         }
  45     }
  46
  47     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  48         efl_select_model_class_get();
  49     /// <summary>Initializes a new instance of the <see cref="SelectModel"/> class.</summary>
  50     /// <param name="parent">Parent instance.</param>
  51     /// <param name="model">Model that is/will be See <see cref="Efl.Ui.IView.SetModel" /></param>
  52     /// <param name="index">Position of this object in the parent model. See <see cref="Efl.CompositeModel.SetIndex" /></param>
  53     public SelectModel(Efl.Object parent
  54             , Efl.IModel model, uint? index = null) : base(efl_select_model_class_get(), parent)
  55     {
  56         if (Efl.Eo.Globals.ParamHelperCheck(model))
  57         {
  58             SetModel(Efl.Eo.Globals.GetParamHelper(model));
  59         }
  60
  61         if (Efl.Eo.Globals.ParamHelperCheck(index))
  62         {
  63             SetIndex(Efl.Eo.Globals.GetParamHelper(index));
  64         }
  65
  66         FinishInstantiation();
  67     }
  68
  69     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  70     /// Do not call this constructor directly.</summary>
  71     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  72     protected SelectModel(ConstructingHandle ch) : base(ch)
  73     {
  74     }
  75
  76     /// <summary>Initializes a new instance of the <see cref="SelectModel"/> class.
  77     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  78     /// <param name="wh">The native pointer to be wrapped.</param>
  79     protected SelectModel(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  80     {
  81     }
  82
  83     /// <summary>Initializes a new instance of the <see cref="SelectModel"/> class.
  84     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  85     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  86     /// <param name="parent">The Efl.Object parent of this instance.</param>
  87     protected SelectModel(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  88     {
  89     }
  90
  91     /// <value><see cref="Efl.SelectModelSelectedEvt_Args"/></value>
  92     public event EventHandler<Efl.SelectModelSelectedEvt_Args> SelectedEvt
  93     {
  94         add
  95         {
  96             lock (eflBindingEventLock)
  97             {
  98                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  99                 {
 100                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 101                     if (obj != null)
 102                     {
 103                         Efl.SelectModelSelectedEvt_Args args = new Efl.SelectModelSelectedEvt_Args();
 104                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 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_SELECT_MODEL_EVENT_SELECTED";
 118                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 119             }
 120         }
 121
 122         remove
 123         {
 124             lock (eflBindingEventLock)
 125             {
 126                 string key = "_EFL_SELECT_MODEL_EVENT_SELECTED";
 127                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 128             }
 129         }
 130     }
 131     /// <summary>Method to raise event SelectedEvt.</summary>
 132     public void OnSelectedEvt(Efl.SelectModelSelectedEvt_Args e)
 133     {
 134         var key = "_EFL_SELECT_MODEL_EVENT_SELECTED";
 135         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 136         if (desc == IntPtr.Zero)
 137         {
 138             Eina.Log.Error($"Failed to get native event {key}");
 139             return;
 140         }
 141
 142         IntPtr info = e.arg.NativeHandle;
 143         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 144     }
 145     /// <value><see cref="Efl.SelectModelUnselectedEvt_Args"/></value>
 146     public event EventHandler<Efl.SelectModelUnselectedEvt_Args> UnselectedEvt
 147     {
 148         add
 149         {
 150             lock (eflBindingEventLock)
 151             {
 152                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 153                 {
 154                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 155                     if (obj != null)
 156                     {
 157                         Efl.SelectModelUnselectedEvt_Args args = new Efl.SelectModelUnselectedEvt_Args();
 158                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 159                         try
 160                         {
 161                             value?.Invoke(obj, args);
 162                         }
 163                         catch (Exception e)
 164                         {
 165                             Eina.Log.Error(e.ToString());
 166                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 167                         }
 168                     }
 169                 };
 170
 171                 string key = "_EFL_SELECT_MODEL_EVENT_UNSELECTED";
 172                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 173             }
 174         }
 175
 176         remove
 177         {
 178             lock (eflBindingEventLock)
 179             {
 180                 string key = "_EFL_SELECT_MODEL_EVENT_UNSELECTED";
 181                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 182             }
 183         }
 184     }
 185     /// <summary>Method to raise event UnselectedEvt.</summary>
 186     public void OnUnselectedEvt(Efl.SelectModelUnselectedEvt_Args e)
 187     {
 188         var key = "_EFL_SELECT_MODEL_EVENT_UNSELECTED";
 189         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 190         if (desc == IntPtr.Zero)
 191         {
 192             Eina.Log.Error($"Failed to get native event {key}");
 193             return;
 194         }
 195
 196         IntPtr info = e.arg.NativeHandle;
 197         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 198     }
 199     /// <summary>Define if we support only one exclusive selection at a time when set to <c>true</c>.
 200     /// If disable with <c>false</c>, it will have the behavior of a multi select mode.</summary>
 201     /// <returns><c>true</c> will enable the exclusive mode.</returns>
 202     virtual public bool GetSingleSelection() {
 203          var _ret_var = Efl.SelectModel.NativeMethods.efl_select_model_single_selection_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 204         Eina.Error.RaiseIfUnhandledException();
 205         return _ret_var;
 206  }
 207     /// <summary>Define if we support only one exclusive selection at a time when set to <c>true</c>.
 208     /// If disable with <c>false</c>, it will have the behavior of a multi select mode.</summary>
 209     /// <param name="enable"><c>true</c> will enable the exclusive mode.</param>
 210     virtual public void SetSingleSelection(bool enable) {
 211                                  Efl.SelectModel.NativeMethods.efl_select_model_single_selection_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),enable);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <summary>Get an iterator of all the selected child of this model.</summary>
 215     /// <returns>The iterator give indexes of selected child. It is valid until any change is made on the model.</returns>
 216     virtual public Eina.Iterator<ulong> GetSelected() {
 217          var _ret_var = Efl.SelectModel.NativeMethods.efl_select_model_selected_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 218         Eina.Error.RaiseIfUnhandledException();
 219         return new Eina.Iterator<ulong>(_ret_var, false);
 220  }
 221     /// <summary>Get an iterator of all the child of this model that are not selected.</summary>
 222     /// <returns>The iterator give indexes of unselected child. It is valid until any change is made on the model.</returns>
 223     virtual public Eina.Iterator<ulong> GetUnselected() {
 224          var _ret_var = Efl.SelectModel.NativeMethods.efl_select_model_unselected_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 225         Eina.Error.RaiseIfUnhandledException();
 226         return new Eina.Iterator<ulong>(_ret_var, false);
 227  }
 228     /// <summary>Define if we support only one exclusive selection at a time when set to <c>true</c>.
 229     /// If disable with <c>false</c>, it will have the behavior of a multi select mode.</summary>
 230     /// <value><c>true</c> will enable the exclusive mode.</value>
 231     public bool SingleSelection {
 232         get { return GetSingleSelection(); }
 233         set { SetSingleSelection(value); }
 234     }
 235     private static IntPtr GetEflClassStatic()
 236     {
 237         return Efl.SelectModel.efl_select_model_class_get();
 238     }
 239     /// <summary>Wrapper for native methods and virtual method delegates.
 240     /// For internal use by generated code only.</summary>
 241     public new class NativeMethods : Efl.BooleanModel.NativeMethods
 242     {
 243         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 244         /// <summary>Gets the list of Eo operations to override.</summary>
 245         /// <returns>The list of Eo operations to be overload.</returns>
 246         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 247         {
 248             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 249             var methods = Efl.Eo.Globals.GetUserMethods(type);
 250
 251             if (efl_select_model_single_selection_get_static_delegate == null)
 252             {
 253                 efl_select_model_single_selection_get_static_delegate = new efl_select_model_single_selection_get_delegate(single_selection_get);
 254             }
 255
 256             if (methods.FirstOrDefault(m => m.Name == "GetSingleSelection") != null)
 257             {
 258                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_select_model_single_selection_get"), func = Marshal.GetFunctionPointerForDelegate(efl_select_model_single_selection_get_static_delegate) });
 259             }
 260
 261             if (efl_select_model_single_selection_set_static_delegate == null)
 262             {
 263                 efl_select_model_single_selection_set_static_delegate = new efl_select_model_single_selection_set_delegate(single_selection_set);
 264             }
 265
 266             if (methods.FirstOrDefault(m => m.Name == "SetSingleSelection") != null)
 267             {
 268                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_select_model_single_selection_set"), func = Marshal.GetFunctionPointerForDelegate(efl_select_model_single_selection_set_static_delegate) });
 269             }
 270
 271             if (efl_select_model_selected_get_static_delegate == null)
 272             {
 273                 efl_select_model_selected_get_static_delegate = new efl_select_model_selected_get_delegate(selected_get);
 274             }
 275
 276             if (methods.FirstOrDefault(m => m.Name == "GetSelected") != null)
 277             {
 278                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_select_model_selected_get"), func = Marshal.GetFunctionPointerForDelegate(efl_select_model_selected_get_static_delegate) });
 279             }
 280
 281             if (efl_select_model_unselected_get_static_delegate == null)
 282             {
 283                 efl_select_model_unselected_get_static_delegate = new efl_select_model_unselected_get_delegate(unselected_get);
 284             }
 285
 286             if (methods.FirstOrDefault(m => m.Name == "GetUnselected") != null)
 287             {
 288                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_select_model_unselected_get"), func = Marshal.GetFunctionPointerForDelegate(efl_select_model_unselected_get_static_delegate) });
 289             }
 290
 291             descs.AddRange(base.GetEoOps(type));
 292             return descs;
 293         }
 294         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 295         /// <returns>The native class pointer.</returns>
 296         public override IntPtr GetEflClass()
 297         {
 298             return Efl.SelectModel.efl_select_model_class_get();
 299         }
 300
 301         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 302
 303         [return: MarshalAs(UnmanagedType.U1)]
 304         private delegate bool efl_select_model_single_selection_get_delegate(System.IntPtr obj, System.IntPtr pd);
 305
 306         [return: MarshalAs(UnmanagedType.U1)]
 307         public delegate bool efl_select_model_single_selection_get_api_delegate(System.IntPtr obj);
 308
 309         public static Efl.Eo.FunctionWrapper<efl_select_model_single_selection_get_api_delegate> efl_select_model_single_selection_get_ptr = new Efl.Eo.FunctionWrapper<efl_select_model_single_selection_get_api_delegate>(Module, "efl_select_model_single_selection_get");
 310
 311         private static bool single_selection_get(System.IntPtr obj, System.IntPtr pd)
 312         {
 313             Eina.Log.Debug("function efl_select_model_single_selection_get was called");
 314             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 315             if (ws != null)
 316             {
 317             bool _ret_var = default(bool);
 318                 try
 319                 {
 320                     _ret_var = ((SelectModel)ws.Target).GetSingleSelection();
 321                 }
 322                 catch (Exception e)
 323                 {
 324                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 325                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 326                 }
 327
 328         return _ret_var;
 329
 330             }
 331             else
 332             {
 333                 return efl_select_model_single_selection_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 334             }
 335         }
 336
 337         private static efl_select_model_single_selection_get_delegate efl_select_model_single_selection_get_static_delegate;
 338
 339
 340         private delegate void efl_select_model_single_selection_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
 341
 342
 343         public delegate void efl_select_model_single_selection_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
 344
 345         public static Efl.Eo.FunctionWrapper<efl_select_model_single_selection_set_api_delegate> efl_select_model_single_selection_set_ptr = new Efl.Eo.FunctionWrapper<efl_select_model_single_selection_set_api_delegate>(Module, "efl_select_model_single_selection_set");
 346
 347         private static void single_selection_set(System.IntPtr obj, System.IntPtr pd, bool enable)
 348         {
 349             Eina.Log.Debug("function efl_select_model_single_selection_set was called");
 350             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 351             if (ws != null)
 352             {
 353
 354                 try
 355                 {
 356                     ((SelectModel)ws.Target).SetSingleSelection(enable);
 357                 }
 358                 catch (Exception e)
 359                 {
 360                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 361                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 362                 }
 363
 364
 365             }
 366             else
 367             {
 368                 efl_select_model_single_selection_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enable);
 369             }
 370         }
 371
 372         private static efl_select_model_single_selection_set_delegate efl_select_model_single_selection_set_static_delegate;
 373
 374
 375         private delegate System.IntPtr efl_select_model_selected_get_delegate(System.IntPtr obj, System.IntPtr pd);
 376
 377
 378         public delegate System.IntPtr efl_select_model_selected_get_api_delegate(System.IntPtr obj);
 379
 380         public static Efl.Eo.FunctionWrapper<efl_select_model_selected_get_api_delegate> efl_select_model_selected_get_ptr = new Efl.Eo.FunctionWrapper<efl_select_model_selected_get_api_delegate>(Module, "efl_select_model_selected_get");
 381
 382         private static System.IntPtr selected_get(System.IntPtr obj, System.IntPtr pd)
 383         {
 384             Eina.Log.Debug("function efl_select_model_selected_get was called");
 385             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 386             if (ws != null)
 387             {
 388             Eina.Iterator<ulong> _ret_var = default(Eina.Iterator<ulong>);
 389                 try
 390                 {
 391                     _ret_var = ((SelectModel)ws.Target).GetSelected();
 392                 }
 393                 catch (Exception e)
 394                 {
 395                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 396                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 397                 }
 398
 399         return _ret_var.Handle;
 400
 401             }
 402             else
 403             {
 404                 return efl_select_model_selected_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 405             }
 406         }
 407
 408         private static efl_select_model_selected_get_delegate efl_select_model_selected_get_static_delegate;
 409
 410
 411         private delegate System.IntPtr efl_select_model_unselected_get_delegate(System.IntPtr obj, System.IntPtr pd);
 412
 413
 414         public delegate System.IntPtr efl_select_model_unselected_get_api_delegate(System.IntPtr obj);
 415
 416         public static Efl.Eo.FunctionWrapper<efl_select_model_unselected_get_api_delegate> efl_select_model_unselected_get_ptr = new Efl.Eo.FunctionWrapper<efl_select_model_unselected_get_api_delegate>(Module, "efl_select_model_unselected_get");
 417
 418         private static System.IntPtr unselected_get(System.IntPtr obj, System.IntPtr pd)
 419         {
 420             Eina.Log.Debug("function efl_select_model_unselected_get was called");
 421             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 422             if (ws != null)
 423             {
 424             Eina.Iterator<ulong> _ret_var = default(Eina.Iterator<ulong>);
 425                 try
 426                 {
 427                     _ret_var = ((SelectModel)ws.Target).GetUnselected();
 428                 }
 429                 catch (Exception e)
 430                 {
 431                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 432                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 433                 }
 434
 435         return _ret_var.Handle;
 436
 437             }
 438             else
 439             {
 440                 return efl_select_model_unselected_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 441             }
 442         }
 443
 444         private static efl_select_model_unselected_get_delegate efl_select_model_unselected_get_static_delegate;
 445
 446         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 447
 448 }
 449 }
 450 }
 451
 452 #if EFL_BETA
 453 #pragma warning disable CS1591
 454 public static class EflSelectModel_ExtensionMethods {
 455     public static Efl.BindableProperty<bool> SingleSelection<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.SelectModel, T>magic = null) where T : Efl.SelectModel {
 456         return new Efl.BindableProperty<bool>("single_selection", fac);
 457     }
 458
 459 }
 460 #pragma warning restore CS1591
 461 #endif