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