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