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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Interface that contains properties regarding the displaying of a range.</summary>
  13 [Efl.Ui.IRangeDisplayConcrete.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public interface IRangeDisplay :
  16     Efl.Eo.IWrapper, IDisposable
  17 {
  18     /// <summary>Control the range value (in percentage) on a given range widget
  19 /// Use this call to set range levels.
  20 ///
  21 /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
  22 /// <returns>The range value (must be between $0.0 and 1.0)</returns>
  23 double GetRangeValue();
  24     /// <summary>Control the range value (in percentage) on a given range widget
  25 /// Use this call to set range levels.
  26 ///
  27 /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
  28 /// <param name="val">The range value (must be between $0.0 and 1.0)</param>
  29 void SetRangeValue(double val);
  30     /// <summary>Get the minimum and maximum values of the given range widget.
  31 /// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
  32 /// <param name="min">The minimum value.</param>
  33 /// <param name="max">The maximum value.</param>
  34 void GetRangeLimits(out double min, out double max);
  35     /// <summary>Set the minimum and maximum values for given range widget.
  36 /// Define the allowed range of values to be selected by the user.
  37 ///
  38 /// If actual value is less than <c>min</c>, it will be updated to <c>min</c>. If it is bigger then <c>max</c>, will be updated to <c>max</c>. The actual value can be obtained with <see cref="Efl.Ui.IRangeDisplay.GetRangeValue"/>
  39 ///
  40 /// The minimum and maximum values may be different for each class.
  41 ///
  42 /// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
  43 /// <param name="min">The minimum value.</param>
  44 /// <param name="max">The maximum value.</param>
  45 void SetRangeLimits(double min, double max);
  46                     /// <summary>Control the range value (in percentage) on a given range widget
  47     /// Use this call to set range levels.
  48     ///
  49     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
  50     /// <value>The range value (must be between $0.0 and 1.0)</value>
  51     double RangeValue {
  52         get ;
  53         set ;
  54     }
  55 }
  56 /// <summary>Interface that contains properties regarding the displaying of a range.</summary>
  57 sealed public class IRangeDisplayConcrete :
  58     Efl.Eo.EoWrapper
  59     , IRangeDisplay
  60
  61 {
  62     ///<summary>Pointer to the native class description.</summary>
  63     public override System.IntPtr NativeClass
  64     {
  65         get
  66         {
  67             if (((object)this).GetType() == typeof(IRangeDisplayConcrete))
  68             {
  69                 return GetEflClassStatic();
  70             }
  71             else
  72             {
  73                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  74             }
  75         }
  76     }
  77
  78     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  79     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  80     private IRangeDisplayConcrete(ConstructingHandle ch) : base(ch)
  81     {
  82     }
  83
  84     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  85         efl_ui_range_display_interface_get();
  86     /// <summary>Initializes a new instance of the <see cref="IRangeDisplay"/> class.
  87     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  88     /// <param name="wh">The native pointer to be wrapped.</param>
  89     private IRangeDisplayConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  90     {
  91     }
  92
  93     /// <summary>Control the range value (in percentage) on a given range widget
  94     /// Use this call to set range levels.
  95     ///
  96     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
  97     /// <returns>The range value (must be between $0.0 and 1.0)</returns>
  98     public double GetRangeValue() {
  99          var _ret_var = Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_get_ptr.Value.Delegate(this.NativeHandle);
 100         Eina.Error.RaiseIfUnhandledException();
 101         return _ret_var;
 102  }
 103     /// <summary>Control the range value (in percentage) on a given range widget
 104     /// Use this call to set range levels.
 105     ///
 106     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
 107     /// <param name="val">The range value (must be between $0.0 and 1.0)</param>
 108     public void SetRangeValue(double val) {
 109                                  Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_set_ptr.Value.Delegate(this.NativeHandle,val);
 110         Eina.Error.RaiseIfUnhandledException();
 111                          }
 112     /// <summary>Get the minimum and maximum values of the given range widget.
 113     /// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
 114     /// <param name="min">The minimum value.</param>
 115     /// <param name="max">The maximum value.</param>
 116     public void GetRangeLimits(out double min, out double max) {
 117                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate(this.NativeHandle,out min, out max);
 118         Eina.Error.RaiseIfUnhandledException();
 119                                          }
 120     /// <summary>Set the minimum and maximum values for given range widget.
 121     /// Define the allowed range of values to be selected by the user.
 122     ///
 123     /// If actual value is less than <c>min</c>, it will be updated to <c>min</c>. If it is bigger then <c>max</c>, will be updated to <c>max</c>. The actual value can be obtained with <see cref="Efl.Ui.IRangeDisplay.GetRangeValue"/>
 124     ///
 125     /// The minimum and maximum values may be different for each class.
 126     ///
 127     /// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
 128     /// <param name="min">The minimum value.</param>
 129     /// <param name="max">The maximum value.</param>
 130     public void SetRangeLimits(double min, double max) {
 131                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate(this.NativeHandle,min, max);
 132         Eina.Error.RaiseIfUnhandledException();
 133                                          }
 134     /// <summary>Control the range value (in percentage) on a given range widget
 135     /// Use this call to set range levels.
 136     ///
 137     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
 138     /// <value>The range value (must be between $0.0 and 1.0)</value>
 139     public double RangeValue {
 140         get { return GetRangeValue(); }
 141         set { SetRangeValue(value); }
 142     }
 143     private static IntPtr GetEflClassStatic()
 144     {
 145         return Efl.Ui.IRangeDisplayConcrete.efl_ui_range_display_interface_get();
 146     }
 147     /// <summary>Wrapper for native methods and virtual method delegates.
 148     /// For internal use by generated code only.</summary>
 149     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 150     {
 151         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 152         /// <summary>Gets the list of Eo operations to override.</summary>
 153         /// <returns>The list of Eo operations to be overload.</returns>
 154         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 155         {
 156             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 157             var methods = Efl.Eo.Globals.GetUserMethods(type);
 158
 159             if (efl_ui_range_value_get_static_delegate == null)
 160             {
 161                 efl_ui_range_value_get_static_delegate = new efl_ui_range_value_get_delegate(range_value_get);
 162             }
 163
 164             if (methods.FirstOrDefault(m => m.Name == "GetRangeValue") != null)
 165             {
 166                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_get_static_delegate) });
 167             }
 168
 169             if (efl_ui_range_value_set_static_delegate == null)
 170             {
 171                 efl_ui_range_value_set_static_delegate = new efl_ui_range_value_set_delegate(range_value_set);
 172             }
 173
 174             if (methods.FirstOrDefault(m => m.Name == "SetRangeValue") != null)
 175             {
 176                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
 177             }
 178
 179             if (efl_ui_range_limits_get_static_delegate == null)
 180             {
 181                 efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
 182             }
 183
 184             if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
 185             {
 186                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
 187             }
 188
 189             if (efl_ui_range_limits_set_static_delegate == null)
 190             {
 191                 efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
 192             }
 193
 194             if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
 195             {
 196                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
 197             }
 198
 199             return descs;
 200         }
 201         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 202         /// <returns>The native class pointer.</returns>
 203         public override IntPtr GetEflClass()
 204         {
 205             return Efl.Ui.IRangeDisplayConcrete.efl_ui_range_display_interface_get();
 206         }
 207
 208         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 209
 210
 211         private delegate double efl_ui_range_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
 212
 213
 214         public delegate double efl_ui_range_value_get_api_delegate(System.IntPtr obj);
 215
 216         public static Efl.Eo.FunctionWrapper<efl_ui_range_value_get_api_delegate> efl_ui_range_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_value_get_api_delegate>(Module, "efl_ui_range_value_get");
 217
 218         private static double range_value_get(System.IntPtr obj, System.IntPtr pd)
 219         {
 220             Eina.Log.Debug("function efl_ui_range_value_get was called");
 221             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 222             if (ws != null)
 223             {
 224             double _ret_var = default(double);
 225                 try
 226                 {
 227                     _ret_var = ((IRangeDisplay)ws.Target).GetRangeValue();
 228                 }
 229                 catch (Exception e)
 230                 {
 231                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 232                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 233                 }
 234
 235         return _ret_var;
 236
 237             }
 238             else
 239             {
 240                 return efl_ui_range_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 241             }
 242         }
 243
 244         private static efl_ui_range_value_get_delegate efl_ui_range_value_get_static_delegate;
 245
 246
 247         private delegate void efl_ui_range_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  double val);
 248
 249
 250         public delegate void efl_ui_range_value_set_api_delegate(System.IntPtr obj,  double val);
 251
 252         public static Efl.Eo.FunctionWrapper<efl_ui_range_value_set_api_delegate> efl_ui_range_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_value_set_api_delegate>(Module, "efl_ui_range_value_set");
 253
 254         private static void range_value_set(System.IntPtr obj, System.IntPtr pd, double val)
 255         {
 256             Eina.Log.Debug("function efl_ui_range_value_set was called");
 257             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 258             if (ws != null)
 259             {
 260
 261                 try
 262                 {
 263                     ((IRangeDisplay)ws.Target).SetRangeValue(val);
 264                 }
 265                 catch (Exception e)
 266                 {
 267                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 268                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 269                 }
 270
 271
 272             }
 273             else
 274             {
 275                 efl_ui_range_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 276             }
 277         }
 278
 279         private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
 280
 281
 282         private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double min,  out double max);
 283
 284
 285         public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj,  out double min,  out double max);
 286
 287         public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
 288
 289         private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
 290         {
 291             Eina.Log.Debug("function efl_ui_range_limits_get was called");
 292             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 293             if (ws != null)
 294             {
 295                         min = default(double);        max = default(double);
 296                 try
 297                 {
 298                     ((IRangeDisplay)ws.Target).GetRangeLimits(out min, out max);
 299                 }
 300                 catch (Exception e)
 301                 {
 302                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 303                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 304                 }
 305
 306
 307             }
 308             else
 309             {
 310                 efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
 311             }
 312         }
 313
 314         private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
 315
 316
 317         private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd,  double min,  double max);
 318
 319
 320         public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj,  double min,  double max);
 321
 322         public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
 323
 324         private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
 325         {
 326             Eina.Log.Debug("function efl_ui_range_limits_set was called");
 327             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 328             if (ws != null)
 329             {
 330
 331                 try
 332                 {
 333                     ((IRangeDisplay)ws.Target).SetRangeLimits(min, max);
 334                 }
 335                 catch (Exception e)
 336                 {
 337                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 338                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 339                 }
 340
 341
 342             }
 343             else
 344             {
 345                 efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
 346             }
 347         }
 348
 349         private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
 350
 351         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 352
 353 }
 354 }
 355 }
 356
 357 }
 358