internals/src/EflSharp/EflSharp/efl/efl_gfx_arrangement.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 Gfx {
  11
  12 /// <summary>API common to all UI container objects.</summary>
  13 [Efl.Gfx.IArrangementConcrete.NativeMethods]
  14 public interface IArrangement :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Alignment of the container within its bounds</summary>
  18 /// <param name="align_horiz">Horizontal alignment</param>
  19 /// <param name="align_vert">Vertical alignment</param>
  20 void GetContentAlign(out double align_horiz, out double align_vert);
  21     /// <summary>Alignment of the container within its bounds</summary>
  22 /// <param name="align_horiz">Horizontal alignment</param>
  23 /// <param name="align_vert">Vertical alignment</param>
  24 void SetContentAlign(double align_horiz, double align_vert);
  25     /// <summary>Padding between items contained in this object.</summary>
  26 /// <param name="pad_horiz">Horizontal padding</param>
  27 /// <param name="pad_vert">Vertical padding</param>
  28 /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  29 void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable);
  30     /// <summary>Padding between items contained in this object.</summary>
  31 /// <param name="pad_horiz">Horizontal padding</param>
  32 /// <param name="pad_vert">Vertical padding</param>
  33 /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  34 void SetContentPadding(double pad_horiz, double pad_vert, bool scalable);
  35                 }
  36 /// <summary>API common to all UI container objects.</summary>
  37 sealed public class IArrangementConcrete :
  38     Efl.Eo.EoWrapper
  39     , IArrangement
  40
  41 {
  42     ///<summary>Pointer to the native class description.</summary>
  43     public override System.IntPtr NativeClass
  44     {
  45         get
  46         {
  47             if (((object)this).GetType() == typeof(IArrangementConcrete))
  48             {
  49                 return GetEflClassStatic();
  50             }
  51             else
  52             {
  53                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  54             }
  55         }
  56     }
  57
  58     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  59         efl_gfx_arrangement_interface_get();
  60     /// <summary>Initializes a new instance of the <see cref="IArrangement"/> class.
  61     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  62     private IArrangementConcrete(System.IntPtr raw) : base(raw)
  63     {
  64     }
  65
  66     /// <summary>Alignment of the container within its bounds</summary>
  67     /// <param name="align_horiz">Horizontal alignment</param>
  68     /// <param name="align_vert">Vertical alignment</param>
  69     public void GetContentAlign(out double align_horiz, out double align_vert) {
  70                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_get_ptr.Value.Delegate(this.NativeHandle,out align_horiz, out align_vert);
  71         Eina.Error.RaiseIfUnhandledException();
  72                                          }
  73     /// <summary>Alignment of the container within its bounds</summary>
  74     /// <param name="align_horiz">Horizontal alignment</param>
  75     /// <param name="align_vert">Vertical alignment</param>
  76     public void SetContentAlign(double align_horiz, double align_vert) {
  77                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_set_ptr.Value.Delegate(this.NativeHandle,align_horiz, align_vert);
  78         Eina.Error.RaiseIfUnhandledException();
  79                                          }
  80     /// <summary>Padding between items contained in this object.</summary>
  81     /// <param name="pad_horiz">Horizontal padding</param>
  82     /// <param name="pad_vert">Vertical padding</param>
  83     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  84     public void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable) {
  85                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate(this.NativeHandle,out pad_horiz, out pad_vert, out scalable);
  86         Eina.Error.RaiseIfUnhandledException();
  87                                                          }
  88     /// <summary>Padding between items contained in this object.</summary>
  89     /// <param name="pad_horiz">Horizontal padding</param>
  90     /// <param name="pad_vert">Vertical padding</param>
  91     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
  92     public void SetContentPadding(double pad_horiz, double pad_vert, bool scalable) {
  93                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate(this.NativeHandle,pad_horiz, pad_vert, scalable);
  94         Eina.Error.RaiseIfUnhandledException();
  95                                                          }
  96     private static IntPtr GetEflClassStatic()
  97     {
  98         return Efl.Gfx.IArrangementConcrete.efl_gfx_arrangement_interface_get();
  99     }
 100     /// <summary>Wrapper for native methods and virtual method delegates.
 101     /// For internal use by generated code only.</summary>
 102     public class NativeMethods  : Efl.Eo.NativeClass
 103     {
 104         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 105         /// <summary>Gets the list of Eo operations to override.</summary>
 106         /// <returns>The list of Eo operations to be overload.</returns>
 107         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 108         {
 109             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 110             var methods = Efl.Eo.Globals.GetUserMethods(type);
 111
 112             if (efl_gfx_arrangement_content_align_get_static_delegate == null)
 113             {
 114                 efl_gfx_arrangement_content_align_get_static_delegate = new efl_gfx_arrangement_content_align_get_delegate(content_align_get);
 115             }
 116
 117             if (methods.FirstOrDefault(m => m.Name == "GetContentAlign") != null)
 118             {
 119                 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) });
 120             }
 121
 122             if (efl_gfx_arrangement_content_align_set_static_delegate == null)
 123             {
 124                 efl_gfx_arrangement_content_align_set_static_delegate = new efl_gfx_arrangement_content_align_set_delegate(content_align_set);
 125             }
 126
 127             if (methods.FirstOrDefault(m => m.Name == "SetContentAlign") != null)
 128             {
 129                 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) });
 130             }
 131
 132             if (efl_gfx_arrangement_content_padding_get_static_delegate == null)
 133             {
 134                 efl_gfx_arrangement_content_padding_get_static_delegate = new efl_gfx_arrangement_content_padding_get_delegate(content_padding_get);
 135             }
 136
 137             if (methods.FirstOrDefault(m => m.Name == "GetContentPadding") != null)
 138             {
 139                 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) });
 140             }
 141
 142             if (efl_gfx_arrangement_content_padding_set_static_delegate == null)
 143             {
 144                 efl_gfx_arrangement_content_padding_set_static_delegate = new efl_gfx_arrangement_content_padding_set_delegate(content_padding_set);
 145             }
 146
 147             if (methods.FirstOrDefault(m => m.Name == "SetContentPadding") != null)
 148             {
 149                 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) });
 150             }
 151
 152             return descs;
 153         }
 154         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 155         /// <returns>The native class pointer.</returns>
 156         public override IntPtr GetEflClass()
 157         {
 158             return Efl.Gfx.IArrangementConcrete.efl_gfx_arrangement_interface_get();
 159         }
 160
 161         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 162
 163
 164         private delegate void efl_gfx_arrangement_content_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert);
 165
 166
 167         public delegate void efl_gfx_arrangement_content_align_get_api_delegate(System.IntPtr obj,  out double align_horiz,  out double align_vert);
 168
 169         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");
 170
 171         private static void content_align_get(System.IntPtr obj, System.IntPtr pd, out double align_horiz, out double align_vert)
 172         {
 173             Eina.Log.Debug("function efl_gfx_arrangement_content_align_get was called");
 174             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 175             if (ws != null)
 176             {
 177                         align_horiz = default(double);        align_vert = default(double);
 178                 try
 179                 {
 180                     ((IArrangement)ws.Target).GetContentAlign(out align_horiz, out align_vert);
 181                 }
 182                 catch (Exception e)
 183                 {
 184                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 185                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 186                 }
 187
 188
 189             }
 190             else
 191             {
 192                 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);
 193             }
 194         }
 195
 196         private static efl_gfx_arrangement_content_align_get_delegate efl_gfx_arrangement_content_align_get_static_delegate;
 197
 198
 199         private delegate void efl_gfx_arrangement_content_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert);
 200
 201
 202         public delegate void efl_gfx_arrangement_content_align_set_api_delegate(System.IntPtr obj,  double align_horiz,  double align_vert);
 203
 204         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");
 205
 206         private static void content_align_set(System.IntPtr obj, System.IntPtr pd, double align_horiz, double align_vert)
 207         {
 208             Eina.Log.Debug("function efl_gfx_arrangement_content_align_set was called");
 209             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 210             if (ws != null)
 211             {
 212
 213                 try
 214                 {
 215                     ((IArrangement)ws.Target).SetContentAlign(align_horiz, align_vert);
 216                 }
 217                 catch (Exception e)
 218                 {
 219                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 220                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 221                 }
 222
 223
 224             }
 225             else
 226             {
 227                 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);
 228             }
 229         }
 230
 231         private static efl_gfx_arrangement_content_align_set_delegate efl_gfx_arrangement_content_align_set_static_delegate;
 232
 233
 234         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);
 235
 236
 237         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);
 238
 239         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");
 240
 241         private static void content_padding_get(System.IntPtr obj, System.IntPtr pd, out double pad_horiz, out double pad_vert, out bool scalable)
 242         {
 243             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_get was called");
 244             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 245             if (ws != null)
 246             {
 247                                 pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
 248                 try
 249                 {
 250                     ((IArrangement)ws.Target).GetContentPadding(out pad_horiz, out pad_vert, out scalable);
 251                 }
 252                 catch (Exception e)
 253                 {
 254                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 255                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 256                 }
 257
 258
 259             }
 260             else
 261             {
 262                 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);
 263             }
 264         }
 265
 266         private static efl_gfx_arrangement_content_padding_get_delegate efl_gfx_arrangement_content_padding_get_static_delegate;
 267
 268
 269         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);
 270
 271
 272         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);
 273
 274         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");
 275
 276         private static void content_padding_set(System.IntPtr obj, System.IntPtr pd, double pad_horiz, double pad_vert, bool scalable)
 277         {
 278             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_set was called");
 279             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 280             if (ws != null)
 281             {
 282
 283                 try
 284                 {
 285                     ((IArrangement)ws.Target).SetContentPadding(pad_horiz, pad_vert, scalable);
 286                 }
 287                 catch (Exception e)
 288                 {
 289                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 290                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 291                 }
 292
 293
 294             }
 295             else
 296             {
 297                 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);
 298             }
 299         }
 300
 301         private static efl_gfx_arrangement_content_padding_set_delegate efl_gfx_arrangement_content_padding_set_static_delegate;
 302
 303         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 304
 305 }
 306 }
 307 }
 308
 309 }
 310