internals/src/EflSharp/EflSharp/efl/efl_text_font.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 /// <summary>Font settings of the text</summary>
  11 [Efl.ITextFontConcrete.NativeMethods]
  12 [Efl.Eo.BindingEntity]
  13 public interface ITextFont :
  14     Efl.Eo.IWrapper, IDisposable
  15 {
  16     /// <summary>Retrieve the font family and size in use on a given text object.
  17 /// This function allows the font name and size of a text object to be queried. Remember that the font name string is still owned by Evas and should not have free() called on it by the caller of the function.
  18 ///
  19 /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
  20 /// <param name="font">The font family name or filename.</param>
  21 /// <param name="size">The font size, in points.</param>
  22 void GetFont(out System.String font, out Efl.Font.Size size);
  23     /// <summary>Set the font family, filename and size for a given text object.
  24 /// This function allows the font name and size of a text object to be set. The font string has to follow fontconfig&apos;s convention for naming fonts, as it&apos;s the underlying library used to query system fonts by Evas (see the fc-list command&apos;s output, on your system, to get an idea). Alternatively, youe can use the full path to a font file.
  25 ///
  26 /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
  27 /// <param name="font">The font family name or filename.</param>
  28 /// <param name="size">The font size, in points.</param>
  29 void SetFont(System.String font, Efl.Font.Size size);
  30     /// <summary>Get the font file&apos;s path which is being used on a given text object.
  31 /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
  32 /// <returns>The font file&apos;s path.</returns>
  33 System.String GetFontSource();
  34     /// <summary>Set the font (source) file to be used on a given text object.
  35 /// This function allows the font file to be explicitly set for a given text object, overriding system lookup, which will first occur in the given file&apos;s contents.
  36 ///
  37 /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
  38 /// <param name="font_source">The font file&apos;s path.</param>
  39 void SetFontSource(System.String font_source);
  40     /// <summary>Comma-separated list of font fallbacks
  41 /// Will be used in case the primary font isn&apos;t available.</summary>
  42 /// <returns>Font name fallbacks</returns>
  43 System.String GetFontFallbacks();
  44     /// <summary>Comma-separated list of font fallbacks
  45 /// Will be used in case the primary font isn&apos;t available.</summary>
  46 /// <param name="font_fallbacks">Font name fallbacks</param>
  47 void SetFontFallbacks(System.String font_fallbacks);
  48     /// <summary>Type of weight of the displayed font
  49 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
  50 /// <returns>Font weight</returns>
  51 Efl.TextFontWeight GetFontWeight();
  52     /// <summary>Type of weight of the displayed font
  53 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
  54 /// <param name="font_weight">Font weight</param>
  55 void SetFontWeight(Efl.TextFontWeight font_weight);
  56     /// <summary>Type of slant of the displayed font
  57 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
  58 /// <returns>Font slant</returns>
  59 Efl.TextFontSlant GetFontSlant();
  60     /// <summary>Type of slant of the displayed font
  61 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
  62 /// <param name="style">Font slant</param>
  63 void SetFontSlant(Efl.TextFontSlant style);
  64     /// <summary>Type of width of the displayed font
  65 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
  66 /// <returns>Font width</returns>
  67 Efl.TextFontWidth GetFontWidth();
  68     /// <summary>Type of width of the displayed font
  69 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
  70 /// <param name="width">Font width</param>
  71 void SetFontWidth(Efl.TextFontWidth width);
  72     /// <summary>Specific language of the displayed font
  73 /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
  74 /// <returns>Language</returns>
  75 System.String GetFontLang();
  76     /// <summary>Specific language of the displayed font
  77 /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
  78 /// <param name="lang">Language</param>
  79 void SetFontLang(System.String lang);
  80     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
  81 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
  82 /// <returns>Scalable</returns>
  83 Efl.TextFontBitmapScalable GetFontBitmapScalable();
  84     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
  85 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
  86 /// <param name="scalable">Scalable</param>
  87 void SetFontBitmapScalable(Efl.TextFontBitmapScalable scalable);
  88                                                                     /// <summary>Get the font file&apos;s path which is being used on a given text object.
  89     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
  90     /// <value>The font file&apos;s path.</value>
  91     System.String FontSource {
  92         get ;
  93         set ;
  94     }
  95     /// <summary>Comma-separated list of font fallbacks
  96     /// Will be used in case the primary font isn&apos;t available.</summary>
  97     /// <value>Font name fallbacks</value>
  98     System.String FontFallbacks {
  99         get ;
 100         set ;
 101     }
 102     /// <summary>Type of weight of the displayed font
 103     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 104     /// <value>Font weight</value>
 105     Efl.TextFontWeight FontWeight {
 106         get ;
 107         set ;
 108     }
 109     /// <summary>Type of slant of the displayed font
 110     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 111     /// <value>Font slant</value>
 112     Efl.TextFontSlant FontSlant {
 113         get ;
 114         set ;
 115     }
 116     /// <summary>Type of width of the displayed font
 117     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 118     /// <value>Font width</value>
 119     Efl.TextFontWidth FontWidth {
 120         get ;
 121         set ;
 122     }
 123     /// <summary>Specific language of the displayed font
 124     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 125     /// <value>Language</value>
 126     System.String FontLang {
 127         get ;
 128         set ;
 129     }
 130     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 131     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 132     /// <value>Scalable</value>
 133     Efl.TextFontBitmapScalable FontBitmapScalable {
 134         get ;
 135         set ;
 136     }
 137 }
 138 /// <summary>Font settings of the text</summary>
 139 sealed public class ITextFontConcrete :
 140     Efl.Eo.EoWrapper
 141     , ITextFont
 142
 143 {
 144     ///<summary>Pointer to the native class description.</summary>
 145     public override System.IntPtr NativeClass
 146     {
 147         get
 148         {
 149             if (((object)this).GetType() == typeof(ITextFontConcrete))
 150             {
 151                 return GetEflClassStatic();
 152             }
 153             else
 154             {
 155                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 156             }
 157         }
 158     }
 159
 160     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 161     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 162     private ITextFontConcrete(ConstructingHandle ch) : base(ch)
 163     {
 164     }
 165
 166     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 167         efl_text_font_interface_get();
 168     /// <summary>Initializes a new instance of the <see cref="ITextFont"/> class.
 169     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 170     /// <param name="wh">The native pointer to be wrapped.</param>
 171     private ITextFontConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 172     {
 173     }
 174
 175     /// <summary>Retrieve the font family and size in use on a given text object.
 176     /// This function allows the font name and size of a text object to be queried. Remember that the font name string is still owned by Evas and should not have free() called on it by the caller of the function.
 177     ///
 178     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 179     /// <param name="font">The font family name or filename.</param>
 180     /// <param name="size">The font size, in points.</param>
 181     public void GetFont(out System.String font, out Efl.Font.Size size) {
 182                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_get_ptr.Value.Delegate(this.NativeHandle,out font, out size);
 183         Eina.Error.RaiseIfUnhandledException();
 184                                          }
 185     /// <summary>Set the font family, filename and size for a given text object.
 186     /// This function allows the font name and size of a text object to be set. The font string has to follow fontconfig&apos;s convention for naming fonts, as it&apos;s the underlying library used to query system fonts by Evas (see the fc-list command&apos;s output, on your system, to get an idea). Alternatively, youe can use the full path to a font file.
 187     ///
 188     /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
 189     /// <param name="font">The font family name or filename.</param>
 190     /// <param name="size">The font size, in points.</param>
 191     public void SetFont(System.String font, Efl.Font.Size size) {
 192                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_set_ptr.Value.Delegate(this.NativeHandle,font, size);
 193         Eina.Error.RaiseIfUnhandledException();
 194                                          }
 195     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 196     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 197     /// <returns>The font file&apos;s path.</returns>
 198     public System.String GetFontSource() {
 199          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_get_ptr.Value.Delegate(this.NativeHandle);
 200         Eina.Error.RaiseIfUnhandledException();
 201         return _ret_var;
 202  }
 203     /// <summary>Set the font (source) file to be used on a given text object.
 204     /// This function allows the font file to be explicitly set for a given text object, overriding system lookup, which will first occur in the given file&apos;s contents.
 205     ///
 206     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 207     /// <param name="font_source">The font file&apos;s path.</param>
 208     public void SetFontSource(System.String font_source) {
 209                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_set_ptr.Value.Delegate(this.NativeHandle,font_source);
 210         Eina.Error.RaiseIfUnhandledException();
 211                          }
 212     /// <summary>Comma-separated list of font fallbacks
 213     /// Will be used in case the primary font isn&apos;t available.</summary>
 214     /// <returns>Font name fallbacks</returns>
 215     public System.String GetFontFallbacks() {
 216          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_get_ptr.Value.Delegate(this.NativeHandle);
 217         Eina.Error.RaiseIfUnhandledException();
 218         return _ret_var;
 219  }
 220     /// <summary>Comma-separated list of font fallbacks
 221     /// Will be used in case the primary font isn&apos;t available.</summary>
 222     /// <param name="font_fallbacks">Font name fallbacks</param>
 223     public void SetFontFallbacks(System.String font_fallbacks) {
 224                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_set_ptr.Value.Delegate(this.NativeHandle,font_fallbacks);
 225         Eina.Error.RaiseIfUnhandledException();
 226                          }
 227     /// <summary>Type of weight of the displayed font
 228     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 229     /// <returns>Font weight</returns>
 230     public Efl.TextFontWeight GetFontWeight() {
 231          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_get_ptr.Value.Delegate(this.NativeHandle);
 232         Eina.Error.RaiseIfUnhandledException();
 233         return _ret_var;
 234  }
 235     /// <summary>Type of weight of the displayed font
 236     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 237     /// <param name="font_weight">Font weight</param>
 238     public void SetFontWeight(Efl.TextFontWeight font_weight) {
 239                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_set_ptr.Value.Delegate(this.NativeHandle,font_weight);
 240         Eina.Error.RaiseIfUnhandledException();
 241                          }
 242     /// <summary>Type of slant of the displayed font
 243     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 244     /// <returns>Font slant</returns>
 245     public Efl.TextFontSlant GetFontSlant() {
 246          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_get_ptr.Value.Delegate(this.NativeHandle);
 247         Eina.Error.RaiseIfUnhandledException();
 248         return _ret_var;
 249  }
 250     /// <summary>Type of slant of the displayed font
 251     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 252     /// <param name="style">Font slant</param>
 253     public void SetFontSlant(Efl.TextFontSlant style) {
 254                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_set_ptr.Value.Delegate(this.NativeHandle,style);
 255         Eina.Error.RaiseIfUnhandledException();
 256                          }
 257     /// <summary>Type of width of the displayed font
 258     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 259     /// <returns>Font width</returns>
 260     public Efl.TextFontWidth GetFontWidth() {
 261          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_get_ptr.Value.Delegate(this.NativeHandle);
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>Type of width of the displayed font
 266     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 267     /// <param name="width">Font width</param>
 268     public void SetFontWidth(Efl.TextFontWidth width) {
 269                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_set_ptr.Value.Delegate(this.NativeHandle,width);
 270         Eina.Error.RaiseIfUnhandledException();
 271                          }
 272     /// <summary>Specific language of the displayed font
 273     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 274     /// <returns>Language</returns>
 275     public System.String GetFontLang() {
 276          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_get_ptr.Value.Delegate(this.NativeHandle);
 277         Eina.Error.RaiseIfUnhandledException();
 278         return _ret_var;
 279  }
 280     /// <summary>Specific language of the displayed font
 281     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 282     /// <param name="lang">Language</param>
 283     public void SetFontLang(System.String lang) {
 284                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_set_ptr.Value.Delegate(this.NativeHandle,lang);
 285         Eina.Error.RaiseIfUnhandledException();
 286                          }
 287     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 288     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 289     /// <returns>Scalable</returns>
 290     public Efl.TextFontBitmapScalable GetFontBitmapScalable() {
 291          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(this.NativeHandle);
 292         Eina.Error.RaiseIfUnhandledException();
 293         return _ret_var;
 294  }
 295     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 296     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 297     /// <param name="scalable">Scalable</param>
 298     public void SetFontBitmapScalable(Efl.TextFontBitmapScalable scalable) {
 299                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(this.NativeHandle,scalable);
 300         Eina.Error.RaiseIfUnhandledException();
 301                          }
 302     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 303     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 304     /// <value>The font file&apos;s path.</value>
 305     public System.String FontSource {
 306         get { return GetFontSource(); }
 307         set { SetFontSource(value); }
 308     }
 309     /// <summary>Comma-separated list of font fallbacks
 310     /// Will be used in case the primary font isn&apos;t available.</summary>
 311     /// <value>Font name fallbacks</value>
 312     public System.String FontFallbacks {
 313         get { return GetFontFallbacks(); }
 314         set { SetFontFallbacks(value); }
 315     }
 316     /// <summary>Type of weight of the displayed font
 317     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 318     /// <value>Font weight</value>
 319     public Efl.TextFontWeight FontWeight {
 320         get { return GetFontWeight(); }
 321         set { SetFontWeight(value); }
 322     }
 323     /// <summary>Type of slant of the displayed font
 324     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 325     /// <value>Font slant</value>
 326     public Efl.TextFontSlant FontSlant {
 327         get { return GetFontSlant(); }
 328         set { SetFontSlant(value); }
 329     }
 330     /// <summary>Type of width of the displayed font
 331     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 332     /// <value>Font width</value>
 333     public Efl.TextFontWidth FontWidth {
 334         get { return GetFontWidth(); }
 335         set { SetFontWidth(value); }
 336     }
 337     /// <summary>Specific language of the displayed font
 338     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 339     /// <value>Language</value>
 340     public System.String FontLang {
 341         get { return GetFontLang(); }
 342         set { SetFontLang(value); }
 343     }
 344     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 345     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 346     /// <value>Scalable</value>
 347     public Efl.TextFontBitmapScalable FontBitmapScalable {
 348         get { return GetFontBitmapScalable(); }
 349         set { SetFontBitmapScalable(value); }
 350     }
 351     private static IntPtr GetEflClassStatic()
 352     {
 353         return Efl.ITextFontConcrete.efl_text_font_interface_get();
 354     }
 355     /// <summary>Wrapper for native methods and virtual method delegates.
 356     /// For internal use by generated code only.</summary>
 357     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 358     {
 359         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 360         /// <summary>Gets the list of Eo operations to override.</summary>
 361         /// <returns>The list of Eo operations to be overload.</returns>
 362         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 363         {
 364             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 365             var methods = Efl.Eo.Globals.GetUserMethods(type);
 366
 367             if (efl_text_font_get_static_delegate == null)
 368             {
 369                 efl_text_font_get_static_delegate = new efl_text_font_get_delegate(font_get);
 370             }
 371
 372             if (methods.FirstOrDefault(m => m.Name == "GetFont") != null)
 373             {
 374                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_get_static_delegate) });
 375             }
 376
 377             if (efl_text_font_set_static_delegate == null)
 378             {
 379                 efl_text_font_set_static_delegate = new efl_text_font_set_delegate(font_set);
 380             }
 381
 382             if (methods.FirstOrDefault(m => m.Name == "SetFont") != null)
 383             {
 384                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_set_static_delegate) });
 385             }
 386
 387             if (efl_text_font_source_get_static_delegate == null)
 388             {
 389                 efl_text_font_source_get_static_delegate = new efl_text_font_source_get_delegate(font_source_get);
 390             }
 391
 392             if (methods.FirstOrDefault(m => m.Name == "GetFontSource") != null)
 393             {
 394                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_source_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_source_get_static_delegate) });
 395             }
 396
 397             if (efl_text_font_source_set_static_delegate == null)
 398             {
 399                 efl_text_font_source_set_static_delegate = new efl_text_font_source_set_delegate(font_source_set);
 400             }
 401
 402             if (methods.FirstOrDefault(m => m.Name == "SetFontSource") != null)
 403             {
 404                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_source_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_source_set_static_delegate) });
 405             }
 406
 407             if (efl_text_font_fallbacks_get_static_delegate == null)
 408             {
 409                 efl_text_font_fallbacks_get_static_delegate = new efl_text_font_fallbacks_get_delegate(font_fallbacks_get);
 410             }
 411
 412             if (methods.FirstOrDefault(m => m.Name == "GetFontFallbacks") != null)
 413             {
 414                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_fallbacks_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_fallbacks_get_static_delegate) });
 415             }
 416
 417             if (efl_text_font_fallbacks_set_static_delegate == null)
 418             {
 419                 efl_text_font_fallbacks_set_static_delegate = new efl_text_font_fallbacks_set_delegate(font_fallbacks_set);
 420             }
 421
 422             if (methods.FirstOrDefault(m => m.Name == "SetFontFallbacks") != null)
 423             {
 424                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_fallbacks_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_fallbacks_set_static_delegate) });
 425             }
 426
 427             if (efl_text_font_weight_get_static_delegate == null)
 428             {
 429                 efl_text_font_weight_get_static_delegate = new efl_text_font_weight_get_delegate(font_weight_get);
 430             }
 431
 432             if (methods.FirstOrDefault(m => m.Name == "GetFontWeight") != null)
 433             {
 434                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_weight_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_weight_get_static_delegate) });
 435             }
 436
 437             if (efl_text_font_weight_set_static_delegate == null)
 438             {
 439                 efl_text_font_weight_set_static_delegate = new efl_text_font_weight_set_delegate(font_weight_set);
 440             }
 441
 442             if (methods.FirstOrDefault(m => m.Name == "SetFontWeight") != null)
 443             {
 444                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_weight_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_weight_set_static_delegate) });
 445             }
 446
 447             if (efl_text_font_slant_get_static_delegate == null)
 448             {
 449                 efl_text_font_slant_get_static_delegate = new efl_text_font_slant_get_delegate(font_slant_get);
 450             }
 451
 452             if (methods.FirstOrDefault(m => m.Name == "GetFontSlant") != null)
 453             {
 454                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_slant_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_slant_get_static_delegate) });
 455             }
 456
 457             if (efl_text_font_slant_set_static_delegate == null)
 458             {
 459                 efl_text_font_slant_set_static_delegate = new efl_text_font_slant_set_delegate(font_slant_set);
 460             }
 461
 462             if (methods.FirstOrDefault(m => m.Name == "SetFontSlant") != null)
 463             {
 464                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_slant_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_slant_set_static_delegate) });
 465             }
 466
 467             if (efl_text_font_width_get_static_delegate == null)
 468             {
 469                 efl_text_font_width_get_static_delegate = new efl_text_font_width_get_delegate(font_width_get);
 470             }
 471
 472             if (methods.FirstOrDefault(m => m.Name == "GetFontWidth") != null)
 473             {
 474                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_width_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_width_get_static_delegate) });
 475             }
 476
 477             if (efl_text_font_width_set_static_delegate == null)
 478             {
 479                 efl_text_font_width_set_static_delegate = new efl_text_font_width_set_delegate(font_width_set);
 480             }
 481
 482             if (methods.FirstOrDefault(m => m.Name == "SetFontWidth") != null)
 483             {
 484                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_width_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_width_set_static_delegate) });
 485             }
 486
 487             if (efl_text_font_lang_get_static_delegate == null)
 488             {
 489                 efl_text_font_lang_get_static_delegate = new efl_text_font_lang_get_delegate(font_lang_get);
 490             }
 491
 492             if (methods.FirstOrDefault(m => m.Name == "GetFontLang") != null)
 493             {
 494                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_lang_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_lang_get_static_delegate) });
 495             }
 496
 497             if (efl_text_font_lang_set_static_delegate == null)
 498             {
 499                 efl_text_font_lang_set_static_delegate = new efl_text_font_lang_set_delegate(font_lang_set);
 500             }
 501
 502             if (methods.FirstOrDefault(m => m.Name == "SetFontLang") != null)
 503             {
 504                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_lang_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_lang_set_static_delegate) });
 505             }
 506
 507             if (efl_text_font_bitmap_scalable_get_static_delegate == null)
 508             {
 509                 efl_text_font_bitmap_scalable_get_static_delegate = new efl_text_font_bitmap_scalable_get_delegate(font_bitmap_scalable_get);
 510             }
 511
 512             if (methods.FirstOrDefault(m => m.Name == "GetFontBitmapScalable") != null)
 513             {
 514                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_bitmap_scalable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_bitmap_scalable_get_static_delegate) });
 515             }
 516
 517             if (efl_text_font_bitmap_scalable_set_static_delegate == null)
 518             {
 519                 efl_text_font_bitmap_scalable_set_static_delegate = new efl_text_font_bitmap_scalable_set_delegate(font_bitmap_scalable_set);
 520             }
 521
 522             if (methods.FirstOrDefault(m => m.Name == "SetFontBitmapScalable") != null)
 523             {
 524                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_bitmap_scalable_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_bitmap_scalable_set_static_delegate) });
 525             }
 526
 527             return descs;
 528         }
 529         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 530         /// <returns>The native class pointer.</returns>
 531         public override IntPtr GetEflClass()
 532         {
 533             return Efl.ITextFontConcrete.efl_text_font_interface_get();
 534         }
 535
 536         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 537
 538
 539         private delegate void efl_text_font_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String font,  out Efl.Font.Size size);
 540
 541
 542         public delegate void efl_text_font_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String font,  out Efl.Font.Size size);
 543
 544         public static Efl.Eo.FunctionWrapper<efl_text_font_get_api_delegate> efl_text_font_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_get_api_delegate>(Module, "efl_text_font_get");
 545
 546         private static void font_get(System.IntPtr obj, System.IntPtr pd, out System.String font, out Efl.Font.Size size)
 547         {
 548             Eina.Log.Debug("function efl_text_font_get was called");
 549             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 550             if (ws != null)
 551             {
 552                         System.String _out_font = default(System.String);
 553         size = default(Efl.Font.Size);
 554                 try
 555                 {
 556                     ((ITextFont)ws.Target).GetFont(out _out_font, out size);
 557                 }
 558                 catch (Exception e)
 559                 {
 560                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 561                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 562                 }
 563
 564         font = _out_font;
 565
 566             }
 567             else
 568             {
 569                 efl_text_font_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out font, out size);
 570             }
 571         }
 572
 573         private static efl_text_font_get_delegate efl_text_font_get_static_delegate;
 574
 575
 576         private delegate void efl_text_font_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font,  Efl.Font.Size size);
 577
 578
 579         public delegate void efl_text_font_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font,  Efl.Font.Size size);
 580
 581         public static Efl.Eo.FunctionWrapper<efl_text_font_set_api_delegate> efl_text_font_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_set_api_delegate>(Module, "efl_text_font_set");
 582
 583         private static void font_set(System.IntPtr obj, System.IntPtr pd, System.String font, Efl.Font.Size size)
 584         {
 585             Eina.Log.Debug("function efl_text_font_set was called");
 586             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 587             if (ws != null)
 588             {
 589
 590                 try
 591                 {
 592                     ((ITextFont)ws.Target).SetFont(font, size);
 593                 }
 594                 catch (Exception e)
 595                 {
 596                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 597                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598                 }
 599
 600
 601             }
 602             else
 603             {
 604                 efl_text_font_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font, size);
 605             }
 606         }
 607
 608         private static efl_text_font_set_delegate efl_text_font_set_static_delegate;
 609
 610         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 611         private delegate System.String efl_text_font_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
 612
 613         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 614         public delegate System.String efl_text_font_source_get_api_delegate(System.IntPtr obj);
 615
 616         public static Efl.Eo.FunctionWrapper<efl_text_font_source_get_api_delegate> efl_text_font_source_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_source_get_api_delegate>(Module, "efl_text_font_source_get");
 617
 618         private static System.String font_source_get(System.IntPtr obj, System.IntPtr pd)
 619         {
 620             Eina.Log.Debug("function efl_text_font_source_get was called");
 621             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 622             if (ws != null)
 623             {
 624             System.String _ret_var = default(System.String);
 625                 try
 626                 {
 627                     _ret_var = ((ITextFont)ws.Target).GetFontSource();
 628                 }
 629                 catch (Exception e)
 630                 {
 631                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 632                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 633                 }
 634
 635         return _ret_var;
 636
 637             }
 638             else
 639             {
 640                 return efl_text_font_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 641             }
 642         }
 643
 644         private static efl_text_font_source_get_delegate efl_text_font_source_get_static_delegate;
 645
 646
 647         private delegate void efl_text_font_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_source);
 648
 649
 650         public delegate void efl_text_font_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_source);
 651
 652         public static Efl.Eo.FunctionWrapper<efl_text_font_source_set_api_delegate> efl_text_font_source_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_source_set_api_delegate>(Module, "efl_text_font_source_set");
 653
 654         private static void font_source_set(System.IntPtr obj, System.IntPtr pd, System.String font_source)
 655         {
 656             Eina.Log.Debug("function efl_text_font_source_set was called");
 657             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 658             if (ws != null)
 659             {
 660
 661                 try
 662                 {
 663                     ((ITextFont)ws.Target).SetFontSource(font_source);
 664                 }
 665                 catch (Exception e)
 666                 {
 667                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 668                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 669                 }
 670
 671
 672             }
 673             else
 674             {
 675                 efl_text_font_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_source);
 676             }
 677         }
 678
 679         private static efl_text_font_source_set_delegate efl_text_font_source_set_static_delegate;
 680
 681         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 682         private delegate System.String efl_text_font_fallbacks_get_delegate(System.IntPtr obj, System.IntPtr pd);
 683
 684         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 685         public delegate System.String efl_text_font_fallbacks_get_api_delegate(System.IntPtr obj);
 686
 687         public static Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_get_api_delegate> efl_text_font_fallbacks_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_get_api_delegate>(Module, "efl_text_font_fallbacks_get");
 688
 689         private static System.String font_fallbacks_get(System.IntPtr obj, System.IntPtr pd)
 690         {
 691             Eina.Log.Debug("function efl_text_font_fallbacks_get was called");
 692             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 693             if (ws != null)
 694             {
 695             System.String _ret_var = default(System.String);
 696                 try
 697                 {
 698                     _ret_var = ((ITextFont)ws.Target).GetFontFallbacks();
 699                 }
 700                 catch (Exception e)
 701                 {
 702                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 703                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 704                 }
 705
 706         return _ret_var;
 707
 708             }
 709             else
 710             {
 711                 return efl_text_font_fallbacks_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 712             }
 713         }
 714
 715         private static efl_text_font_fallbacks_get_delegate efl_text_font_fallbacks_get_static_delegate;
 716
 717
 718         private delegate void efl_text_font_fallbacks_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_fallbacks);
 719
 720
 721         public delegate void efl_text_font_fallbacks_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_fallbacks);
 722
 723         public static Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_set_api_delegate> efl_text_font_fallbacks_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_set_api_delegate>(Module, "efl_text_font_fallbacks_set");
 724
 725         private static void font_fallbacks_set(System.IntPtr obj, System.IntPtr pd, System.String font_fallbacks)
 726         {
 727             Eina.Log.Debug("function efl_text_font_fallbacks_set was called");
 728             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 729             if (ws != null)
 730             {
 731
 732                 try
 733                 {
 734                     ((ITextFont)ws.Target).SetFontFallbacks(font_fallbacks);
 735                 }
 736                 catch (Exception e)
 737                 {
 738                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 739                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 740                 }
 741
 742
 743             }
 744             else
 745             {
 746                 efl_text_font_fallbacks_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_fallbacks);
 747             }
 748         }
 749
 750         private static efl_text_font_fallbacks_set_delegate efl_text_font_fallbacks_set_static_delegate;
 751
 752
 753         private delegate Efl.TextFontWeight efl_text_font_weight_get_delegate(System.IntPtr obj, System.IntPtr pd);
 754
 755
 756         public delegate Efl.TextFontWeight efl_text_font_weight_get_api_delegate(System.IntPtr obj);
 757
 758         public static Efl.Eo.FunctionWrapper<efl_text_font_weight_get_api_delegate> efl_text_font_weight_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_weight_get_api_delegate>(Module, "efl_text_font_weight_get");
 759
 760         private static Efl.TextFontWeight font_weight_get(System.IntPtr obj, System.IntPtr pd)
 761         {
 762             Eina.Log.Debug("function efl_text_font_weight_get was called");
 763             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 764             if (ws != null)
 765             {
 766             Efl.TextFontWeight _ret_var = default(Efl.TextFontWeight);
 767                 try
 768                 {
 769                     _ret_var = ((ITextFont)ws.Target).GetFontWeight();
 770                 }
 771                 catch (Exception e)
 772                 {
 773                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 774                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 775                 }
 776
 777         return _ret_var;
 778
 779             }
 780             else
 781             {
 782                 return efl_text_font_weight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 783             }
 784         }
 785
 786         private static efl_text_font_weight_get_delegate efl_text_font_weight_get_static_delegate;
 787
 788
 789         private delegate void efl_text_font_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWeight font_weight);
 790
 791
 792         public delegate void efl_text_font_weight_set_api_delegate(System.IntPtr obj,  Efl.TextFontWeight font_weight);
 793
 794         public static Efl.Eo.FunctionWrapper<efl_text_font_weight_set_api_delegate> efl_text_font_weight_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_weight_set_api_delegate>(Module, "efl_text_font_weight_set");
 795
 796         private static void font_weight_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWeight font_weight)
 797         {
 798             Eina.Log.Debug("function efl_text_font_weight_set was called");
 799             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 800             if (ws != null)
 801             {
 802
 803                 try
 804                 {
 805                     ((ITextFont)ws.Target).SetFontWeight(font_weight);
 806                 }
 807                 catch (Exception e)
 808                 {
 809                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 810                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 811                 }
 812
 813
 814             }
 815             else
 816             {
 817                 efl_text_font_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_weight);
 818             }
 819         }
 820
 821         private static efl_text_font_weight_set_delegate efl_text_font_weight_set_static_delegate;
 822
 823
 824         private delegate Efl.TextFontSlant efl_text_font_slant_get_delegate(System.IntPtr obj, System.IntPtr pd);
 825
 826
 827         public delegate Efl.TextFontSlant efl_text_font_slant_get_api_delegate(System.IntPtr obj);
 828
 829         public static Efl.Eo.FunctionWrapper<efl_text_font_slant_get_api_delegate> efl_text_font_slant_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_slant_get_api_delegate>(Module, "efl_text_font_slant_get");
 830
 831         private static Efl.TextFontSlant font_slant_get(System.IntPtr obj, System.IntPtr pd)
 832         {
 833             Eina.Log.Debug("function efl_text_font_slant_get was called");
 834             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 835             if (ws != null)
 836             {
 837             Efl.TextFontSlant _ret_var = default(Efl.TextFontSlant);
 838                 try
 839                 {
 840                     _ret_var = ((ITextFont)ws.Target).GetFontSlant();
 841                 }
 842                 catch (Exception e)
 843                 {
 844                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 845                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 846                 }
 847
 848         return _ret_var;
 849
 850             }
 851             else
 852             {
 853                 return efl_text_font_slant_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 854             }
 855         }
 856
 857         private static efl_text_font_slant_get_delegate efl_text_font_slant_get_static_delegate;
 858
 859
 860         private delegate void efl_text_font_slant_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontSlant style);
 861
 862
 863         public delegate void efl_text_font_slant_set_api_delegate(System.IntPtr obj,  Efl.TextFontSlant style);
 864
 865         public static Efl.Eo.FunctionWrapper<efl_text_font_slant_set_api_delegate> efl_text_font_slant_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_slant_set_api_delegate>(Module, "efl_text_font_slant_set");
 866
 867         private static void font_slant_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontSlant style)
 868         {
 869             Eina.Log.Debug("function efl_text_font_slant_set was called");
 870             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 871             if (ws != null)
 872             {
 873
 874                 try
 875                 {
 876                     ((ITextFont)ws.Target).SetFontSlant(style);
 877                 }
 878                 catch (Exception e)
 879                 {
 880                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 881                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 882                 }
 883
 884
 885             }
 886             else
 887             {
 888                 efl_text_font_slant_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), style);
 889             }
 890         }
 891
 892         private static efl_text_font_slant_set_delegate efl_text_font_slant_set_static_delegate;
 893
 894
 895         private delegate Efl.TextFontWidth efl_text_font_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
 896
 897
 898         public delegate Efl.TextFontWidth efl_text_font_width_get_api_delegate(System.IntPtr obj);
 899
 900         public static Efl.Eo.FunctionWrapper<efl_text_font_width_get_api_delegate> efl_text_font_width_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_width_get_api_delegate>(Module, "efl_text_font_width_get");
 901
 902         private static Efl.TextFontWidth font_width_get(System.IntPtr obj, System.IntPtr pd)
 903         {
 904             Eina.Log.Debug("function efl_text_font_width_get was called");
 905             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 906             if (ws != null)
 907             {
 908             Efl.TextFontWidth _ret_var = default(Efl.TextFontWidth);
 909                 try
 910                 {
 911                     _ret_var = ((ITextFont)ws.Target).GetFontWidth();
 912                 }
 913                 catch (Exception e)
 914                 {
 915                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 916                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 917                 }
 918
 919         return _ret_var;
 920
 921             }
 922             else
 923             {
 924                 return efl_text_font_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 925             }
 926         }
 927
 928         private static efl_text_font_width_get_delegate efl_text_font_width_get_static_delegate;
 929
 930
 931         private delegate void efl_text_font_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWidth width);
 932
 933
 934         public delegate void efl_text_font_width_set_api_delegate(System.IntPtr obj,  Efl.TextFontWidth width);
 935
 936         public static Efl.Eo.FunctionWrapper<efl_text_font_width_set_api_delegate> efl_text_font_width_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_width_set_api_delegate>(Module, "efl_text_font_width_set");
 937
 938         private static void font_width_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWidth width)
 939         {
 940             Eina.Log.Debug("function efl_text_font_width_set was called");
 941             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 942             if (ws != null)
 943             {
 944
 945                 try
 946                 {
 947                     ((ITextFont)ws.Target).SetFontWidth(width);
 948                 }
 949                 catch (Exception e)
 950                 {
 951                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 952                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 953                 }
 954
 955
 956             }
 957             else
 958             {
 959                 efl_text_font_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
 960             }
 961         }
 962
 963         private static efl_text_font_width_set_delegate efl_text_font_width_set_static_delegate;
 964
 965         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 966         private delegate System.String efl_text_font_lang_get_delegate(System.IntPtr obj, System.IntPtr pd);
 967
 968         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 969         public delegate System.String efl_text_font_lang_get_api_delegate(System.IntPtr obj);
 970
 971         public static Efl.Eo.FunctionWrapper<efl_text_font_lang_get_api_delegate> efl_text_font_lang_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_lang_get_api_delegate>(Module, "efl_text_font_lang_get");
 972
 973         private static System.String font_lang_get(System.IntPtr obj, System.IntPtr pd)
 974         {
 975             Eina.Log.Debug("function efl_text_font_lang_get was called");
 976             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 977             if (ws != null)
 978             {
 979             System.String _ret_var = default(System.String);
 980                 try
 981                 {
 982                     _ret_var = ((ITextFont)ws.Target).GetFontLang();
 983                 }
 984                 catch (Exception e)
 985                 {
 986                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 987                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 988                 }
 989
 990         return _ret_var;
 991
 992             }
 993             else
 994             {
 995                 return efl_text_font_lang_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 996             }
 997         }
 998
 999         private static efl_text_font_lang_get_delegate efl_text_font_lang_get_static_delegate;
1000
1001
1002         private delegate void efl_text_font_lang_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String lang);
1003
1004
1005         public delegate void efl_text_font_lang_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String lang);
1006
1007         public static Efl.Eo.FunctionWrapper<efl_text_font_lang_set_api_delegate> efl_text_font_lang_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_lang_set_api_delegate>(Module, "efl_text_font_lang_set");
1008
1009         private static void font_lang_set(System.IntPtr obj, System.IntPtr pd, System.String lang)
1010         {
1011             Eina.Log.Debug("function efl_text_font_lang_set was called");
1012             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1013             if (ws != null)
1014             {
1015
1016                 try
1017                 {
1018                     ((ITextFont)ws.Target).SetFontLang(lang);
1019                 }
1020                 catch (Exception e)
1021                 {
1022                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1023                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1024                 }
1025
1026
1027             }
1028             else
1029             {
1030                 efl_text_font_lang_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), lang);
1031             }
1032         }
1033
1034         private static efl_text_font_lang_set_delegate efl_text_font_lang_set_static_delegate;
1035
1036
1037         private delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_delegate(System.IntPtr obj, System.IntPtr pd);
1038
1039
1040         public delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_api_delegate(System.IntPtr obj);
1041
1042         public static Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_get_api_delegate> efl_text_font_bitmap_scalable_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_get_api_delegate>(Module, "efl_text_font_bitmap_scalable_get");
1043
1044         private static Efl.TextFontBitmapScalable font_bitmap_scalable_get(System.IntPtr obj, System.IntPtr pd)
1045         {
1046             Eina.Log.Debug("function efl_text_font_bitmap_scalable_get was called");
1047             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1048             if (ws != null)
1049             {
1050             Efl.TextFontBitmapScalable _ret_var = default(Efl.TextFontBitmapScalable);
1051                 try
1052                 {
1053                     _ret_var = ((ITextFont)ws.Target).GetFontBitmapScalable();
1054                 }
1055                 catch (Exception e)
1056                 {
1057                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1058                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1059                 }
1060
1061         return _ret_var;
1062
1063             }
1064             else
1065             {
1066                 return efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1067             }
1068         }
1069
1070         private static efl_text_font_bitmap_scalable_get_delegate efl_text_font_bitmap_scalable_get_static_delegate;
1071
1072
1073         private delegate void efl_text_font_bitmap_scalable_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontBitmapScalable scalable);
1074
1075
1076         public delegate void efl_text_font_bitmap_scalable_set_api_delegate(System.IntPtr obj,  Efl.TextFontBitmapScalable scalable);
1077
1078         public static Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_set_api_delegate> efl_text_font_bitmap_scalable_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_set_api_delegate>(Module, "efl_text_font_bitmap_scalable_set");
1079
1080         private static void font_bitmap_scalable_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontBitmapScalable scalable)
1081         {
1082             Eina.Log.Debug("function efl_text_font_bitmap_scalable_set was called");
1083             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1084             if (ws != null)
1085             {
1086
1087                 try
1088                 {
1089                     ((ITextFont)ws.Target).SetFontBitmapScalable(scalable);
1090                 }
1091                 catch (Exception e)
1092                 {
1093                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1094                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1095                 }
1096
1097
1098             }
1099             else
1100             {
1101                 efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scalable);
1102             }
1103         }
1104
1105         private static efl_text_font_bitmap_scalable_set_delegate efl_text_font_bitmap_scalable_set_static_delegate;
1106
1107         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1108
1109 }
1110 }
1111 }
1112
1113 namespace Efl {
1114
1115 /// <summary>Type of font weight</summary>
1116 [Efl.Eo.BindingEntity]
1117 public enum TextFontWeight
1118 {
1119 /// <summary>Normal font weight</summary>
1120 Normal = 0,
1121 /// <summary>Thin font weight</summary>
1122 Thin = 1,
1123 /// <summary>Ultralight font weight</summary>
1124 Ultralight = 2,
1125 /// <summary>Extralight font weight</summary>
1126 Extralight = 3,
1127 /// <summary>Light font weight</summary>
1128 Light = 4,
1129 /// <summary>Book font weight</summary>
1130 Book = 5,
1131 /// <summary>Medium font weight</summary>
1132 Medium = 6,
1133 /// <summary>Semibold font weight</summary>
1134 Semibold = 7,
1135 /// <summary>Bold font weight</summary>
1136 Bold = 8,
1137 /// <summary>Ultrabold font weight</summary>
1138 Ultrabold = 9,
1139 /// <summary>Extrabold font weight</summary>
1140 Extrabold = 10,
1141 /// <summary>Black font weight</summary>
1142 Black = 11,
1143 /// <summary>Extrablack font weight</summary>
1144 Extrablack = 12,
1145 }
1146
1147 }
1148
1149 namespace Efl {
1150
1151 /// <summary>Type of font width</summary>
1152 [Efl.Eo.BindingEntity]
1153 public enum TextFontWidth
1154 {
1155 /// <summary>Normal font width</summary>
1156 Normal = 0,
1157 /// <summary>Ultracondensed font width</summary>
1158 Ultracondensed = 1,
1159 /// <summary>Extracondensed font width</summary>
1160 Extracondensed = 2,
1161 /// <summary>Condensed font width</summary>
1162 Condensed = 3,
1163 /// <summary>Semicondensed font width</summary>
1164 Semicondensed = 4,
1165 /// <summary>Semiexpanded font width</summary>
1166 Semiexpanded = 5,
1167 /// <summary>Expanded font width</summary>
1168 Expanded = 6,
1169 /// <summary>Extraexpanded font width</summary>
1170 Extraexpanded = 7,
1171 /// <summary>Ultraexpanded font width</summary>
1172 Ultraexpanded = 8,
1173 }
1174
1175 }
1176
1177 namespace Efl {
1178
1179 /// <summary>Type of font slant</summary>
1180 [Efl.Eo.BindingEntity]
1181 public enum TextFontSlant
1182 {
1183 /// <summary>Normal font slant</summary>
1184 Normal = 0,
1185 /// <summary>Oblique font slant</summary>
1186 Oblique = 1,
1187 /// <summary>Italic font slant</summary>
1188 Italic = 2,
1189 }
1190
1191 }
1192
1193 namespace Efl {
1194
1195 /// <summary>Scalable of bitmap fonts</summary>
1196 [Efl.Eo.BindingEntity]
1197 public enum TextFontBitmapScalable
1198 {
1199 /// <summary>Disable scalable feature for bitmap fonts.</summary>
1200 None = 0,
1201 /// <summary>Enable scalable feature for color bitmap fonts.</summary>
1202 Color = 1,
1203 }
1204
1205 }
1206