internals/src/EflSharp/EflSharp/efl/efl_gfx_arrangement.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 Gfx {
  12
  13 /// <summary>API common to all UI container objects.</summary>
  14 /// <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>
  15 [Efl.Gfx.IArrangementConcrete.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public interface IArrangement :
  18     Efl.Eo.IWrapper, IDisposable
  19 {
  20     /// <summary>Alignment of the container within its bounds</summary>
  21 /// <param name="align_horiz">Horizontal alignment</param>
  22 /// <param name="align_vert">Vertical alignment</param>
  23 void GetContentAlign(out double align_horiz, out double align_vert);
  24     /// <summary>Alignment of the container within its bounds</summary>
  25 /// <param name="align_horiz">Horizontal alignment</param>
  26 /// <param name="align_vert">Vertical alignment</param>
  27 void SetContentAlign(double align_horiz, double align_vert);
  28     /// <summary>Padding between items contained in this object.</summary>
  29 /// <param name="pad_horiz">Horizontal padding</param>
  30 /// <param name="pad_vert">Vertical padding</param>
  31 /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  32 void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable);
  33     /// <summary>Padding between items contained in this object.</summary>
  34 /// <param name="pad_horiz">Horizontal padding</param>
  35 /// <param name="pad_vert">Vertical padding</param>
  36 /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  37 void SetContentPadding(double pad_horiz, double pad_vert, bool scalable);
  38                     /// <summary>Alignment of the container within its bounds</summary>
  39     /// <value>Horizontal alignment</value>
  40     (double, double) ContentAlign {
  41         get;
  42         set;
  43     }
  44     /// <summary>Padding between items contained in this object.</summary>
  45     /// <value>Horizontal padding</value>
  46     (double, double, bool) ContentPadding {
  47         get;
  48         set;
  49     }
  50 }
  51 /// <summary>API common to all UI container objects.</summary>
  52 /// <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>
  53 sealed public  class IArrangementConcrete :
  54     Efl.Eo.EoWrapper
  55     , IArrangement
  56
  57 {
  58     /// <summary>Pointer to the native class description.</summary>
  59     public override System.IntPtr NativeClass
  60     {
  61         get
  62         {
  63             if (((object)this).GetType() == typeof(IArrangementConcrete))
  64             {
  65                 return GetEflClassStatic();
  66             }
  67             else
  68             {
  69                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  70             }
  71         }
  72     }
  73
  74     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  75     /// Do not call this constructor directly.</summary>
  76     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  77     private IArrangementConcrete(ConstructingHandle ch) : base(ch)
  78     {
  79     }
  80
  81     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  82         efl_gfx_arrangement_interface_get();
  83     /// <summary>Initializes a new instance of the <see cref="IArrangement"/> class.
  84     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  85     /// <param name="wh">The native pointer to be wrapped.</param>
  86     private IArrangementConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  87     {
  88     }
  89
  90     /// <summary>Alignment of the container within its bounds</summary>
  91     /// <param name="align_horiz">Horizontal alignment</param>
  92     /// <param name="align_vert">Vertical alignment</param>
  93     public void GetContentAlign(out double align_horiz, out double align_vert) {
  94                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_get_ptr.Value.Delegate(this.NativeHandle,out align_horiz, out align_vert);
  95         Eina.Error.RaiseIfUnhandledException();
  96                                          }
  97     /// <summary>Alignment of the container within its bounds</summary>
  98     /// <param name="align_horiz">Horizontal alignment</param>
  99     /// <param name="align_vert">Vertical alignment</param>
 100     public void SetContentAlign(double align_horiz, double align_vert) {
 101                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_set_ptr.Value.Delegate(this.NativeHandle,align_horiz, align_vert);
 102         Eina.Error.RaiseIfUnhandledException();
 103                                          }
 104     /// <summary>Padding between items contained in this object.</summary>
 105     /// <param name="pad_horiz">Horizontal padding</param>
 106     /// <param name="pad_vert">Vertical padding</param>
 107     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 108     public void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable) {
 109                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate(this.NativeHandle,out pad_horiz, out pad_vert, out scalable);
 110         Eina.Error.RaiseIfUnhandledException();
 111                                                          }
 112     /// <summary>Padding between items contained in this object.</summary>
 113     /// <param name="pad_horiz">Horizontal padding</param>
 114     /// <param name="pad_vert">Vertical padding</param>
 115     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 116     public void SetContentPadding(double pad_horiz, double pad_vert, bool scalable) {
 117                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate(this.NativeHandle,pad_horiz, pad_vert, scalable);
 118         Eina.Error.RaiseIfUnhandledException();
 119                                                          }
 120     /// <summary>Alignment of the container within its bounds</summary>
 121     /// <value>Horizontal alignment</value>
 122     public (double, double) ContentAlign {
 123         get {
 124             double _out_align_horiz = default(double);
 125             double _out_align_vert = default(double);
 126             GetContentAlign(out _out_align_horiz,out _out_align_vert);
 127             return (_out_align_horiz,_out_align_vert);
 128         }
 129         set { SetContentAlign( value.Item1,  value.Item2); }
 130     }
 131     /// <summary>Padding between items contained in this object.</summary>
 132     /// <value>Horizontal padding</value>
 133     public (double, double, bool) ContentPadding {
 134         get {
 135             double _out_pad_horiz = default(double);
 136             double _out_pad_vert = default(double);
 137             bool _out_scalable = default(bool);
 138             GetContentPadding(out _out_pad_horiz,out _out_pad_vert,out _out_scalable);
 139             return (_out_pad_horiz,_out_pad_vert,_out_scalable);
 140         }
 141         set { SetContentPadding( value.Item1,  value.Item2,  value.Item3); }
 142     }
 143     private static IntPtr GetEflClassStatic()
 144     {
 145         return Efl.Gfx.IArrangementConcrete.efl_gfx_arrangement_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_gfx_arrangement_content_align_get_static_delegate == null)
 160             {
 161                 efl_gfx_arrangement_content_align_get_static_delegate = new efl_gfx_arrangement_content_align_get_delegate(content_align_get);
 162             }
 163
 164             if (methods.FirstOrDefault(m => m.Name == "GetContentAlign") != null)
 165             {
 166                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_get_static_delegate) });
 167             }
 168
 169             if (efl_gfx_arrangement_content_align_set_static_delegate == null)
 170             {
 171                 efl_gfx_arrangement_content_align_set_static_delegate = new efl_gfx_arrangement_content_align_set_delegate(content_align_set);
 172             }
 173
 174             if (methods.FirstOrDefault(m => m.Name == "SetContentAlign") != null)
 175             {
 176                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_set_static_delegate) });
 177             }
 178
 179             if (efl_gfx_arrangement_content_padding_get_static_delegate == null)
 180             {
 181                 efl_gfx_arrangement_content_padding_get_static_delegate = new efl_gfx_arrangement_content_padding_get_delegate(content_padding_get);
 182             }
 183
 184             if (methods.FirstOrDefault(m => m.Name == "GetContentPadding") != null)
 185             {
 186                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_get_static_delegate) });
 187             }
 188
 189             if (efl_gfx_arrangement_content_padding_set_static_delegate == null)
 190             {
 191                 efl_gfx_arrangement_content_padding_set_static_delegate = new efl_gfx_arrangement_content_padding_set_delegate(content_padding_set);
 192             }
 193
 194             if (methods.FirstOrDefault(m => m.Name == "SetContentPadding") != null)
 195             {
 196                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_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.Gfx.IArrangementConcrete.efl_gfx_arrangement_interface_get();
 206         }
 207
 208         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 209
 210
 211         private delegate void efl_gfx_arrangement_content_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert);
 212
 213
 214         public delegate void efl_gfx_arrangement_content_align_get_api_delegate(System.IntPtr obj,  out double align_horiz,  out double align_vert);
 215
 216         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate> efl_gfx_arrangement_content_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate>(Module, "efl_gfx_arrangement_content_align_get");
 217
 218         private static void content_align_get(System.IntPtr obj, System.IntPtr pd, out double align_horiz, out double align_vert)
 219         {
 220             Eina.Log.Debug("function efl_gfx_arrangement_content_align_get was called");
 221             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 222             if (ws != null)
 223             {
 224                         align_horiz = default(double);        align_vert = default(double);
 225                 try
 226                 {
 227                     ((IArrangement)ws.Target).GetContentAlign(out align_horiz, out align_vert);
 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
 236             }
 237             else
 238             {
 239                 efl_gfx_arrangement_content_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out align_horiz, out align_vert);
 240             }
 241         }
 242
 243         private static efl_gfx_arrangement_content_align_get_delegate efl_gfx_arrangement_content_align_get_static_delegate;
 244
 245
 246         private delegate void efl_gfx_arrangement_content_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert);
 247
 248
 249         public delegate void efl_gfx_arrangement_content_align_set_api_delegate(System.IntPtr obj,  double align_horiz,  double align_vert);
 250
 251         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate> efl_gfx_arrangement_content_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate>(Module, "efl_gfx_arrangement_content_align_set");
 252
 253         private static void content_align_set(System.IntPtr obj, System.IntPtr pd, double align_horiz, double align_vert)
 254         {
 255             Eina.Log.Debug("function efl_gfx_arrangement_content_align_set was called");
 256             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 257             if (ws != null)
 258             {
 259
 260                 try
 261                 {
 262                     ((IArrangement)ws.Target).SetContentAlign(align_horiz, align_vert);
 263                 }
 264                 catch (Exception e)
 265                 {
 266                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 267                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 268                 }
 269
 270
 271             }
 272             else
 273             {
 274                 efl_gfx_arrangement_content_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), align_horiz, align_vert);
 275             }
 276         }
 277
 278         private static efl_gfx_arrangement_content_align_set_delegate efl_gfx_arrangement_content_align_set_static_delegate;
 279
 280
 281         private delegate void efl_gfx_arrangement_content_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
 282
 283
 284         public delegate void efl_gfx_arrangement_content_padding_get_api_delegate(System.IntPtr obj,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
 285
 286         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate> efl_gfx_arrangement_content_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate>(Module, "efl_gfx_arrangement_content_padding_get");
 287
 288         private static void content_padding_get(System.IntPtr obj, System.IntPtr pd, out double pad_horiz, out double pad_vert, out bool scalable)
 289         {
 290             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_get was called");
 291             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 292             if (ws != null)
 293             {
 294                                 pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
 295                 try
 296                 {
 297                     ((IArrangement)ws.Target).GetContentPadding(out pad_horiz, out pad_vert, out scalable);
 298                 }
 299                 catch (Exception e)
 300                 {
 301                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 302                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 303                 }
 304
 305
 306             }
 307             else
 308             {
 309                 efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out pad_horiz, out pad_vert, out scalable);
 310             }
 311         }
 312
 313         private static efl_gfx_arrangement_content_padding_get_delegate efl_gfx_arrangement_content_padding_get_static_delegate;
 314
 315
 316         private delegate void efl_gfx_arrangement_content_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
 317
 318
 319         public delegate void efl_gfx_arrangement_content_padding_set_api_delegate(System.IntPtr obj,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
 320
 321         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate> efl_gfx_arrangement_content_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate>(Module, "efl_gfx_arrangement_content_padding_set");
 322
 323         private static void content_padding_set(System.IntPtr obj, System.IntPtr pd, double pad_horiz, double pad_vert, bool scalable)
 324         {
 325             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_set was called");
 326             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 327             if (ws != null)
 328             {
 329
 330                 try
 331                 {
 332                     ((IArrangement)ws.Target).SetContentPadding(pad_horiz, pad_vert, scalable);
 333                 }
 334                 catch (Exception e)
 335                 {
 336                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 337                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 338                 }
 339
 340
 341             }
 342             else
 343             {
 344                 efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pad_horiz, pad_vert, scalable);
 345             }
 346         }
 347
 348         private static efl_gfx_arrangement_content_padding_set_delegate efl_gfx_arrangement_content_padding_set_static_delegate;
 349
 350         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 351
 352 }
 353 }
 354 }
 355
 356 }
 357
 358 #if EFL_BETA
 359 #pragma warning disable CS1591
 360 public static class Efl_GfxIArrangementConcrete_ExtensionMethods {
 361
 362
 363 }
 364 #pragma warning restore CS1591
 365 #endif