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.ComponentModel;
   7 namespace Efl {
   8 /// <summary>Font settings of the text</summary>
   9 [ITextFontNativeInherit]
  10 public interface ITextFont :
  11     Efl.Eo.IWrapper, IDisposable
  12 {
  13     /// <summary>Retrieve the font family and size in use on a given text object.
  14 /// 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.
  15 ///
  16 /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
  17 /// <param name="font">The font family name or filename.</param>
  18 /// <param name="size">The font size, in points.</param>
  19 /// <returns></returns>
  20 void GetFont( out System.String font,  out Efl.Font.Size size);
  21     /// <summary>Set the font family, filename and size for a given text object.
  22 /// 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.
  23 ///
  24 /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
  25 /// <param name="font">The font family name or filename.</param>
  26 /// <param name="size">The font size, in points.</param>
  27 /// <returns></returns>
  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 /// <returns></returns>
  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 /// <returns></returns>
  48 void SetFontFallbacks( System.String font_fallbacks);
  49     /// <summary>Type of weight of the displayed font
  50 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
  51 /// <returns>Font weight</returns>
  52 Efl.TextFontWeight GetFontWeight();
  53     /// <summary>Type of weight of the displayed font
  54 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
  55 /// <param name="font_weight">Font weight</param>
  56 /// <returns></returns>
  57 void SetFontWeight( Efl.TextFontWeight font_weight);
  58     /// <summary>Type of slant of the displayed font
  59 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
  60 /// <returns>Font slant</returns>
  61 Efl.TextFontSlant GetFontSlant();
  62     /// <summary>Type of slant of the displayed font
  63 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
  64 /// <param name="style">Font slant</param>
  65 /// <returns></returns>
  66 void SetFontSlant( Efl.TextFontSlant style);
  67     /// <summary>Type of width of the displayed font
  68 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
  69 /// <returns>Font width</returns>
  70 Efl.TextFontWidth GetFontWidth();
  71     /// <summary>Type of width of the displayed font
  72 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
  73 /// <param name="width">Font width</param>
  74 /// <returns></returns>
  75 void SetFontWidth( Efl.TextFontWidth width);
  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 /// <returns>Language</returns>
  79 System.String GetFontLang();
  80     /// <summary>Specific language of the displayed font
  81 /// 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>
  82 /// <param name="lang">Language</param>
  83 /// <returns></returns>
  84 void SetFontLang( System.String lang);
  85     /// <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)
  86 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
  87 /// <returns>Scalable</returns>
  88 Efl.TextFontBitmapScalable GetFontBitmapScalable();
  89     /// <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)
  90 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
  91 /// <param name="scalable">Scalable</param>
  92 /// <returns></returns>
  93 void SetFontBitmapScalable( Efl.TextFontBitmapScalable scalable);
  94                                                                     /// <summary>Get the font file&apos;s path which is being used on a given text object.
  95 /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
  96 /// <value>The font file&apos;s path.</value>
  97     System.String FontSource {
  98         get ;
  99         set ;
 100     }
 101     /// <summary>Comma-separated list of font fallbacks
 102 /// Will be used in case the primary font isn&apos;t available.</summary>
 103 /// <value>Font name fallbacks</value>
 104     System.String FontFallbacks {
 105         get ;
 106         set ;
 107     }
 108     /// <summary>Type of weight of the displayed font
 109 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 110 /// <value>Font weight</value>
 111     Efl.TextFontWeight FontWeight {
 112         get ;
 113         set ;
 114     }
 115     /// <summary>Type of slant of the displayed font
 116 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 117 /// <value>Font slant</value>
 118     Efl.TextFontSlant FontSlant {
 119         get ;
 120         set ;
 121     }
 122     /// <summary>Type of width of the displayed font
 123 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 124 /// <value>Font width</value>
 125     Efl.TextFontWidth FontWidth {
 126         get ;
 127         set ;
 128     }
 129     /// <summary>Specific language of the displayed font
 130 /// 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>
 131 /// <value>Language</value>
 132     System.String FontLang {
 133         get ;
 134         set ;
 135     }
 136     /// <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)
 137 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 138 /// <value>Scalable</value>
 139     Efl.TextFontBitmapScalable FontBitmapScalable {
 140         get ;
 141         set ;
 142     }
 143 }
 144 /// <summary>Font settings of the text</summary>
 145 sealed public class ITextFontConcrete :
 146
 147 ITextFont
 148
 149 {
 150     ///<summary>Pointer to the native class description.</summary>
 151     public System.IntPtr NativeClass {
 152         get {
 153             if (((object)this).GetType() == typeof (ITextFontConcrete))
 154                 return Efl.ITextFontNativeInherit.GetEflClassStatic();
 155             else
 156                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 157         }
 158     }
 159     private  System.IntPtr handle;
 160     ///<summary>Pointer to the native instance.</summary>
 161     public System.IntPtr NativeHandle {
 162         get { return handle; }
 163     }
 164     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 165         efl_text_font_interface_get();
 166     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 167     private ITextFontConcrete(System.IntPtr raw)
 168     {
 169         handle = raw;
 170         RegisterEventProxies();
 171     }
 172     ///<summary>Destructor.</summary>
 173     ~ITextFontConcrete()
 174     {
 175         Dispose(false);
 176     }
 177     ///<summary>Releases the underlying native instance.</summary>
 178     void Dispose(bool disposing)
 179     {
 180         if (handle != System.IntPtr.Zero) {
 181             Efl.Eo.Globals.efl_unref(handle);
 182             handle = System.IntPtr.Zero;
 183         }
 184     }
 185     ///<summary>Releases the underlying native instance.</summary>
 186     public void Dispose()
 187     {
 188         Dispose(true);
 189         GC.SuppressFinalize(this);
 190     }
 191     ///<summary>Verifies if the given object is equal to this one.</summary>
 192     public override bool Equals(object obj)
 193     {
 194         var other = obj as Efl.Object;
 195         if (other == null)
 196             return false;
 197         return this.NativeHandle == other.NativeHandle;
 198     }
 199     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 200     public override int GetHashCode()
 201     {
 202         return this.NativeHandle.ToInt32();
 203     }
 204     ///<summary>Turns the native pointer into a string representation.</summary>
 205     public override String ToString()
 206     {
 207         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 208     }
 209     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 210      void RegisterEventProxies()
 211     {
 212     }
 213     /// <summary>Retrieve the font family and size in use on a given text object.
 214     /// 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.
 215     ///
 216     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 217     /// <param name="font">The font family name or filename.</param>
 218     /// <param name="size">The font size, in points.</param>
 219     /// <returns></returns>
 220     public void GetFont( out System.String font,  out Efl.Font.Size size) {
 221                                                          Efl.ITextFontNativeInherit.efl_text_font_get_ptr.Value.Delegate(this.NativeHandle, out font,  out size);
 222         Eina.Error.RaiseIfUnhandledException();
 223                                          }
 224     /// <summary>Set the font family, filename and size for a given text object.
 225     /// 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.
 226     ///
 227     /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
 228     /// <param name="font">The font family name or filename.</param>
 229     /// <param name="size">The font size, in points.</param>
 230     /// <returns></returns>
 231     public void SetFont( System.String font,  Efl.Font.Size size) {
 232                                                          Efl.ITextFontNativeInherit.efl_text_font_set_ptr.Value.Delegate(this.NativeHandle, font,  size);
 233         Eina.Error.RaiseIfUnhandledException();
 234                                          }
 235     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 236     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 237     /// <returns>The font file&apos;s path.</returns>
 238     public System.String GetFontSource() {
 239          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_source_get_ptr.Value.Delegate(this.NativeHandle);
 240         Eina.Error.RaiseIfUnhandledException();
 241         return _ret_var;
 242  }
 243     /// <summary>Set the font (source) file to be used on a given text object.
 244     /// 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.
 245     ///
 246     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 247     /// <param name="font_source">The font file&apos;s path.</param>
 248     /// <returns></returns>
 249     public void SetFontSource( System.String font_source) {
 250                                  Efl.ITextFontNativeInherit.efl_text_font_source_set_ptr.Value.Delegate(this.NativeHandle, font_source);
 251         Eina.Error.RaiseIfUnhandledException();
 252                          }
 253     /// <summary>Comma-separated list of font fallbacks
 254     /// Will be used in case the primary font isn&apos;t available.</summary>
 255     /// <returns>Font name fallbacks</returns>
 256     public System.String GetFontFallbacks() {
 257          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_fallbacks_get_ptr.Value.Delegate(this.NativeHandle);
 258         Eina.Error.RaiseIfUnhandledException();
 259         return _ret_var;
 260  }
 261     /// <summary>Comma-separated list of font fallbacks
 262     /// Will be used in case the primary font isn&apos;t available.</summary>
 263     /// <param name="font_fallbacks">Font name fallbacks</param>
 264     /// <returns></returns>
 265     public void SetFontFallbacks( System.String font_fallbacks) {
 266                                  Efl.ITextFontNativeInherit.efl_text_font_fallbacks_set_ptr.Value.Delegate(this.NativeHandle, font_fallbacks);
 267         Eina.Error.RaiseIfUnhandledException();
 268                          }
 269     /// <summary>Type of weight of the displayed font
 270     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 271     /// <returns>Font weight</returns>
 272     public Efl.TextFontWeight GetFontWeight() {
 273          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_weight_get_ptr.Value.Delegate(this.NativeHandle);
 274         Eina.Error.RaiseIfUnhandledException();
 275         return _ret_var;
 276  }
 277     /// <summary>Type of weight of the displayed font
 278     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 279     /// <param name="font_weight">Font weight</param>
 280     /// <returns></returns>
 281     public void SetFontWeight( Efl.TextFontWeight font_weight) {
 282                                  Efl.ITextFontNativeInherit.efl_text_font_weight_set_ptr.Value.Delegate(this.NativeHandle, font_weight);
 283         Eina.Error.RaiseIfUnhandledException();
 284                          }
 285     /// <summary>Type of slant of the displayed font
 286     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 287     /// <returns>Font slant</returns>
 288     public Efl.TextFontSlant GetFontSlant() {
 289          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_slant_get_ptr.Value.Delegate(this.NativeHandle);
 290         Eina.Error.RaiseIfUnhandledException();
 291         return _ret_var;
 292  }
 293     /// <summary>Type of slant of the displayed font
 294     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 295     /// <param name="style">Font slant</param>
 296     /// <returns></returns>
 297     public void SetFontSlant( Efl.TextFontSlant style) {
 298                                  Efl.ITextFontNativeInherit.efl_text_font_slant_set_ptr.Value.Delegate(this.NativeHandle, style);
 299         Eina.Error.RaiseIfUnhandledException();
 300                          }
 301     /// <summary>Type of width of the displayed font
 302     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 303     /// <returns>Font width</returns>
 304     public Efl.TextFontWidth GetFontWidth() {
 305          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_width_get_ptr.Value.Delegate(this.NativeHandle);
 306         Eina.Error.RaiseIfUnhandledException();
 307         return _ret_var;
 308  }
 309     /// <summary>Type of width of the displayed font
 310     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 311     /// <param name="width">Font width</param>
 312     /// <returns></returns>
 313     public void SetFontWidth( Efl.TextFontWidth width) {
 314                                  Efl.ITextFontNativeInherit.efl_text_font_width_set_ptr.Value.Delegate(this.NativeHandle, width);
 315         Eina.Error.RaiseIfUnhandledException();
 316                          }
 317     /// <summary>Specific language of the displayed font
 318     /// 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>
 319     /// <returns>Language</returns>
 320     public System.String GetFontLang() {
 321          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_lang_get_ptr.Value.Delegate(this.NativeHandle);
 322         Eina.Error.RaiseIfUnhandledException();
 323         return _ret_var;
 324  }
 325     /// <summary>Specific language of the displayed font
 326     /// 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>
 327     /// <param name="lang">Language</param>
 328     /// <returns></returns>
 329     public void SetFontLang( System.String lang) {
 330                                  Efl.ITextFontNativeInherit.efl_text_font_lang_set_ptr.Value.Delegate(this.NativeHandle, lang);
 331         Eina.Error.RaiseIfUnhandledException();
 332                          }
 333     /// <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)
 334     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 335     /// <returns>Scalable</returns>
 336     public Efl.TextFontBitmapScalable GetFontBitmapScalable() {
 337          var _ret_var = Efl.ITextFontNativeInherit.efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(this.NativeHandle);
 338         Eina.Error.RaiseIfUnhandledException();
 339         return _ret_var;
 340  }
 341     /// <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)
 342     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 343     /// <param name="scalable">Scalable</param>
 344     /// <returns></returns>
 345     public void SetFontBitmapScalable( Efl.TextFontBitmapScalable scalable) {
 346                                  Efl.ITextFontNativeInherit.efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(this.NativeHandle, scalable);
 347         Eina.Error.RaiseIfUnhandledException();
 348                          }
 349     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 350 /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 351 /// <value>The font file&apos;s path.</value>
 352     public System.String FontSource {
 353         get { return GetFontSource(); }
 354         set { SetFontSource( value); }
 355     }
 356     /// <summary>Comma-separated list of font fallbacks
 357 /// Will be used in case the primary font isn&apos;t available.</summary>
 358 /// <value>Font name fallbacks</value>
 359     public System.String FontFallbacks {
 360         get { return GetFontFallbacks(); }
 361         set { SetFontFallbacks( value); }
 362     }
 363     /// <summary>Type of weight of the displayed font
 364 /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 365 /// <value>Font weight</value>
 366     public Efl.TextFontWeight FontWeight {
 367         get { return GetFontWeight(); }
 368         set { SetFontWeight( value); }
 369     }
 370     /// <summary>Type of slant of the displayed font
 371 /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 372 /// <value>Font slant</value>
 373     public Efl.TextFontSlant FontSlant {
 374         get { return GetFontSlant(); }
 375         set { SetFontSlant( value); }
 376     }
 377     /// <summary>Type of width of the displayed font
 378 /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 379 /// <value>Font width</value>
 380     public Efl.TextFontWidth FontWidth {
 381         get { return GetFontWidth(); }
 382         set { SetFontWidth( value); }
 383     }
 384     /// <summary>Specific language of the displayed font
 385 /// 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>
 386 /// <value>Language</value>
 387     public System.String FontLang {
 388         get { return GetFontLang(); }
 389         set { SetFontLang( value); }
 390     }
 391     /// <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)
 392 /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 393 /// <value>Scalable</value>
 394     public Efl.TextFontBitmapScalable FontBitmapScalable {
 395         get { return GetFontBitmapScalable(); }
 396         set { SetFontBitmapScalable( value); }
 397     }
 398     private static IntPtr GetEflClassStatic()
 399     {
 400         return Efl.ITextFontConcrete.efl_text_font_interface_get();
 401     }
 402 }
 403 public class ITextFontNativeInherit  : Efl.Eo.NativeClass{
 404     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 405     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 406     {
 407         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 408         var methods = Efl.Eo.Globals.GetUserMethods(type);
 409         if (efl_text_font_get_static_delegate == null)
 410             efl_text_font_get_static_delegate = new efl_text_font_get_delegate(font_get);
 411         if (methods.FirstOrDefault(m => m.Name == "GetFont") != null)
 412             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)});
 413         if (efl_text_font_set_static_delegate == null)
 414             efl_text_font_set_static_delegate = new efl_text_font_set_delegate(font_set);
 415         if (methods.FirstOrDefault(m => m.Name == "SetFont") != null)
 416             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)});
 417         if (efl_text_font_source_get_static_delegate == null)
 418             efl_text_font_source_get_static_delegate = new efl_text_font_source_get_delegate(font_source_get);
 419         if (methods.FirstOrDefault(m => m.Name == "GetFontSource") != null)
 420             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)});
 421         if (efl_text_font_source_set_static_delegate == null)
 422             efl_text_font_source_set_static_delegate = new efl_text_font_source_set_delegate(font_source_set);
 423         if (methods.FirstOrDefault(m => m.Name == "SetFontSource") != null)
 424             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)});
 425         if (efl_text_font_fallbacks_get_static_delegate == null)
 426             efl_text_font_fallbacks_get_static_delegate = new efl_text_font_fallbacks_get_delegate(font_fallbacks_get);
 427         if (methods.FirstOrDefault(m => m.Name == "GetFontFallbacks") != null)
 428             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)});
 429         if (efl_text_font_fallbacks_set_static_delegate == null)
 430             efl_text_font_fallbacks_set_static_delegate = new efl_text_font_fallbacks_set_delegate(font_fallbacks_set);
 431         if (methods.FirstOrDefault(m => m.Name == "SetFontFallbacks") != null)
 432             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)});
 433         if (efl_text_font_weight_get_static_delegate == null)
 434             efl_text_font_weight_get_static_delegate = new efl_text_font_weight_get_delegate(font_weight_get);
 435         if (methods.FirstOrDefault(m => m.Name == "GetFontWeight") != null)
 436             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)});
 437         if (efl_text_font_weight_set_static_delegate == null)
 438             efl_text_font_weight_set_static_delegate = new efl_text_font_weight_set_delegate(font_weight_set);
 439         if (methods.FirstOrDefault(m => m.Name == "SetFontWeight") != null)
 440             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)});
 441         if (efl_text_font_slant_get_static_delegate == null)
 442             efl_text_font_slant_get_static_delegate = new efl_text_font_slant_get_delegate(font_slant_get);
 443         if (methods.FirstOrDefault(m => m.Name == "GetFontSlant") != null)
 444             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)});
 445         if (efl_text_font_slant_set_static_delegate == null)
 446             efl_text_font_slant_set_static_delegate = new efl_text_font_slant_set_delegate(font_slant_set);
 447         if (methods.FirstOrDefault(m => m.Name == "SetFontSlant") != null)
 448             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)});
 449         if (efl_text_font_width_get_static_delegate == null)
 450             efl_text_font_width_get_static_delegate = new efl_text_font_width_get_delegate(font_width_get);
 451         if (methods.FirstOrDefault(m => m.Name == "GetFontWidth") != null)
 452             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)});
 453         if (efl_text_font_width_set_static_delegate == null)
 454             efl_text_font_width_set_static_delegate = new efl_text_font_width_set_delegate(font_width_set);
 455         if (methods.FirstOrDefault(m => m.Name == "SetFontWidth") != null)
 456             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)});
 457         if (efl_text_font_lang_get_static_delegate == null)
 458             efl_text_font_lang_get_static_delegate = new efl_text_font_lang_get_delegate(font_lang_get);
 459         if (methods.FirstOrDefault(m => m.Name == "GetFontLang") != null)
 460             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)});
 461         if (efl_text_font_lang_set_static_delegate == null)
 462             efl_text_font_lang_set_static_delegate = new efl_text_font_lang_set_delegate(font_lang_set);
 463         if (methods.FirstOrDefault(m => m.Name == "SetFontLang") != null)
 464             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)});
 465         if (efl_text_font_bitmap_scalable_get_static_delegate == null)
 466             efl_text_font_bitmap_scalable_get_static_delegate = new efl_text_font_bitmap_scalable_get_delegate(font_bitmap_scalable_get);
 467         if (methods.FirstOrDefault(m => m.Name == "GetFontBitmapScalable") != null)
 468             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)});
 469         if (efl_text_font_bitmap_scalable_set_static_delegate == null)
 470             efl_text_font_bitmap_scalable_set_static_delegate = new efl_text_font_bitmap_scalable_set_delegate(font_bitmap_scalable_set);
 471         if (methods.FirstOrDefault(m => m.Name == "SetFontBitmapScalable") != null)
 472             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)});
 473         return descs;
 474     }
 475     public override IntPtr GetEflClass()
 476     {
 477         return Efl.ITextFontConcrete.efl_text_font_interface_get();
 478     }
 479     public static  IntPtr GetEflClassStatic()
 480     {
 481         return Efl.ITextFontConcrete.efl_text_font_interface_get();
 482     }
 483
 484
 485      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);
 486
 487
 488      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);
 489      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");
 490      private static void font_get(System.IntPtr obj, System.IntPtr pd,  out System.String font,  out Efl.Font.Size size)
 491     {
 492         Eina.Log.Debug("function efl_text_font_get was called");
 493         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 494         if(wrapper != null) {
 495                                     System.String _out_font = default(System.String);
 496         size = default(Efl.Font.Size);
 497             try {
 498                 ((ITextFont)wrapper).GetFont( out _out_font,  out size);
 499             } catch (Exception e) {
 500                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 501                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 502             }
 503         font = _out_font;
 504                                         } else {
 505             efl_text_font_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out font,  out size);
 506         }
 507     }
 508     private static efl_text_font_get_delegate efl_text_font_get_static_delegate;
 509
 510
 511      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);
 512
 513
 514      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);
 515      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");
 516      private static void font_set(System.IntPtr obj, System.IntPtr pd,  System.String font,  Efl.Font.Size size)
 517     {
 518         Eina.Log.Debug("function efl_text_font_set was called");
 519         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 520         if(wrapper != null) {
 521
 522             try {
 523                 ((ITextFont)wrapper).SetFont( font,  size);
 524             } catch (Exception e) {
 525                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 526                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 527             }
 528                                                 } else {
 529             efl_text_font_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  font,  size);
 530         }
 531     }
 532     private static efl_text_font_set_delegate efl_text_font_set_static_delegate;
 533
 534
 535      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_text_font_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
 536
 537
 538      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_text_font_source_get_api_delegate(System.IntPtr obj);
 539      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");
 540      private static System.String font_source_get(System.IntPtr obj, System.IntPtr pd)
 541     {
 542         Eina.Log.Debug("function efl_text_font_source_get was called");
 543         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 544         if(wrapper != null) {
 545                         System.String _ret_var = default(System.String);
 546             try {
 547                 _ret_var = ((ITextFont)wrapper).GetFontSource();
 548             } catch (Exception e) {
 549                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 550                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 551             }
 552         return _ret_var;
 553         } else {
 554             return efl_text_font_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 555         }
 556     }
 557     private static efl_text_font_source_get_delegate efl_text_font_source_get_static_delegate;
 558
 559
 560      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);
 561
 562
 563      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);
 564      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");
 565      private static void font_source_set(System.IntPtr obj, System.IntPtr pd,  System.String font_source)
 566     {
 567         Eina.Log.Debug("function efl_text_font_source_set was called");
 568         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 569         if(wrapper != null) {
 570
 571             try {
 572                 ((ITextFont)wrapper).SetFontSource( font_source);
 573             } catch (Exception e) {
 574                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 575                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 576             }
 577                                 } else {
 578             efl_text_font_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  font_source);
 579         }
 580     }
 581     private static efl_text_font_source_set_delegate efl_text_font_source_set_static_delegate;
 582
 583
 584      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_text_font_fallbacks_get_delegate(System.IntPtr obj, System.IntPtr pd);
 585
 586
 587      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_text_font_fallbacks_get_api_delegate(System.IntPtr obj);
 588      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");
 589      private static System.String font_fallbacks_get(System.IntPtr obj, System.IntPtr pd)
 590     {
 591         Eina.Log.Debug("function efl_text_font_fallbacks_get was called");
 592         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 593         if(wrapper != null) {
 594                         System.String _ret_var = default(System.String);
 595             try {
 596                 _ret_var = ((ITextFont)wrapper).GetFontFallbacks();
 597             } catch (Exception e) {
 598                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 599                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 600             }
 601         return _ret_var;
 602         } else {
 603             return efl_text_font_fallbacks_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 604         }
 605     }
 606     private static efl_text_font_fallbacks_get_delegate efl_text_font_fallbacks_get_static_delegate;
 607
 608
 609      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);
 610
 611
 612      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);
 613      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");
 614      private static void font_fallbacks_set(System.IntPtr obj, System.IntPtr pd,  System.String font_fallbacks)
 615     {
 616         Eina.Log.Debug("function efl_text_font_fallbacks_set was called");
 617         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 618         if(wrapper != null) {
 619
 620             try {
 621                 ((ITextFont)wrapper).SetFontFallbacks( font_fallbacks);
 622             } catch (Exception e) {
 623                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 624                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 625             }
 626                                 } else {
 627             efl_text_font_fallbacks_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  font_fallbacks);
 628         }
 629     }
 630     private static efl_text_font_fallbacks_set_delegate efl_text_font_fallbacks_set_static_delegate;
 631
 632
 633      private delegate Efl.TextFontWeight efl_text_font_weight_get_delegate(System.IntPtr obj, System.IntPtr pd);
 634
 635
 636      public delegate Efl.TextFontWeight efl_text_font_weight_get_api_delegate(System.IntPtr obj);
 637      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");
 638      private static Efl.TextFontWeight font_weight_get(System.IntPtr obj, System.IntPtr pd)
 639     {
 640         Eina.Log.Debug("function efl_text_font_weight_get was called");
 641         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 642         if(wrapper != null) {
 643                         Efl.TextFontWeight _ret_var = default(Efl.TextFontWeight);
 644             try {
 645                 _ret_var = ((ITextFont)wrapper).GetFontWeight();
 646             } catch (Exception e) {
 647                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 648                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 649             }
 650         return _ret_var;
 651         } else {
 652             return efl_text_font_weight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 653         }
 654     }
 655     private static efl_text_font_weight_get_delegate efl_text_font_weight_get_static_delegate;
 656
 657
 658      private delegate void efl_text_font_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextFontWeight font_weight);
 659
 660
 661      public delegate void efl_text_font_weight_set_api_delegate(System.IntPtr obj,   Efl.TextFontWeight font_weight);
 662      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");
 663      private static void font_weight_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWeight font_weight)
 664     {
 665         Eina.Log.Debug("function efl_text_font_weight_set was called");
 666         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 667         if(wrapper != null) {
 668
 669             try {
 670                 ((ITextFont)wrapper).SetFontWeight( font_weight);
 671             } catch (Exception e) {
 672                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 673                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 674             }
 675                                 } else {
 676             efl_text_font_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  font_weight);
 677         }
 678     }
 679     private static efl_text_font_weight_set_delegate efl_text_font_weight_set_static_delegate;
 680
 681
 682      private delegate Efl.TextFontSlant efl_text_font_slant_get_delegate(System.IntPtr obj, System.IntPtr pd);
 683
 684
 685      public delegate Efl.TextFontSlant efl_text_font_slant_get_api_delegate(System.IntPtr obj);
 686      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");
 687      private static Efl.TextFontSlant font_slant_get(System.IntPtr obj, System.IntPtr pd)
 688     {
 689         Eina.Log.Debug("function efl_text_font_slant_get was called");
 690         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 691         if(wrapper != null) {
 692                         Efl.TextFontSlant _ret_var = default(Efl.TextFontSlant);
 693             try {
 694                 _ret_var = ((ITextFont)wrapper).GetFontSlant();
 695             } catch (Exception e) {
 696                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 697                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 698             }
 699         return _ret_var;
 700         } else {
 701             return efl_text_font_slant_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 702         }
 703     }
 704     private static efl_text_font_slant_get_delegate efl_text_font_slant_get_static_delegate;
 705
 706
 707      private delegate void efl_text_font_slant_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextFontSlant style);
 708
 709
 710      public delegate void efl_text_font_slant_set_api_delegate(System.IntPtr obj,   Efl.TextFontSlant style);
 711      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");
 712      private static void font_slant_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontSlant style)
 713     {
 714         Eina.Log.Debug("function efl_text_font_slant_set was called");
 715         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 716         if(wrapper != null) {
 717
 718             try {
 719                 ((ITextFont)wrapper).SetFontSlant( style);
 720             } catch (Exception e) {
 721                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 722                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 723             }
 724                                 } else {
 725             efl_text_font_slant_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  style);
 726         }
 727     }
 728     private static efl_text_font_slant_set_delegate efl_text_font_slant_set_static_delegate;
 729
 730
 731      private delegate Efl.TextFontWidth efl_text_font_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
 732
 733
 734      public delegate Efl.TextFontWidth efl_text_font_width_get_api_delegate(System.IntPtr obj);
 735      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");
 736      private static Efl.TextFontWidth font_width_get(System.IntPtr obj, System.IntPtr pd)
 737     {
 738         Eina.Log.Debug("function efl_text_font_width_get was called");
 739         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 740         if(wrapper != null) {
 741                         Efl.TextFontWidth _ret_var = default(Efl.TextFontWidth);
 742             try {
 743                 _ret_var = ((ITextFont)wrapper).GetFontWidth();
 744             } catch (Exception e) {
 745                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 746                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 747             }
 748         return _ret_var;
 749         } else {
 750             return efl_text_font_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 751         }
 752     }
 753     private static efl_text_font_width_get_delegate efl_text_font_width_get_static_delegate;
 754
 755
 756      private delegate void efl_text_font_width_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextFontWidth width);
 757
 758
 759      public delegate void efl_text_font_width_set_api_delegate(System.IntPtr obj,   Efl.TextFontWidth width);
 760      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");
 761      private static void font_width_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWidth width)
 762     {
 763         Eina.Log.Debug("function efl_text_font_width_set was called");
 764         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 765         if(wrapper != null) {
 766
 767             try {
 768                 ((ITextFont)wrapper).SetFontWidth( width);
 769             } catch (Exception e) {
 770                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 771                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 772             }
 773                                 } else {
 774             efl_text_font_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  width);
 775         }
 776     }
 777     private static efl_text_font_width_set_delegate efl_text_font_width_set_static_delegate;
 778
 779
 780      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_text_font_lang_get_delegate(System.IntPtr obj, System.IntPtr pd);
 781
 782
 783      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_text_font_lang_get_api_delegate(System.IntPtr obj);
 784      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");
 785      private static System.String font_lang_get(System.IntPtr obj, System.IntPtr pd)
 786     {
 787         Eina.Log.Debug("function efl_text_font_lang_get was called");
 788         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 789         if(wrapper != null) {
 790                         System.String _ret_var = default(System.String);
 791             try {
 792                 _ret_var = ((ITextFont)wrapper).GetFontLang();
 793             } catch (Exception e) {
 794                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 795                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 796             }
 797         return _ret_var;
 798         } else {
 799             return efl_text_font_lang_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 800         }
 801     }
 802     private static efl_text_font_lang_get_delegate efl_text_font_lang_get_static_delegate;
 803
 804
 805      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);
 806
 807
 808      public delegate void efl_text_font_lang_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String lang);
 809      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");
 810      private static void font_lang_set(System.IntPtr obj, System.IntPtr pd,  System.String lang)
 811     {
 812         Eina.Log.Debug("function efl_text_font_lang_set was called");
 813         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 814         if(wrapper != null) {
 815
 816             try {
 817                 ((ITextFont)wrapper).SetFontLang( lang);
 818             } catch (Exception e) {
 819                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 820                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 821             }
 822                                 } else {
 823             efl_text_font_lang_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  lang);
 824         }
 825     }
 826     private static efl_text_font_lang_set_delegate efl_text_font_lang_set_static_delegate;
 827
 828
 829      private delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_delegate(System.IntPtr obj, System.IntPtr pd);
 830
 831
 832      public delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_api_delegate(System.IntPtr obj);
 833      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");
 834      private static Efl.TextFontBitmapScalable font_bitmap_scalable_get(System.IntPtr obj, System.IntPtr pd)
 835     {
 836         Eina.Log.Debug("function efl_text_font_bitmap_scalable_get was called");
 837         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 838         if(wrapper != null) {
 839                         Efl.TextFontBitmapScalable _ret_var = default(Efl.TextFontBitmapScalable);
 840             try {
 841                 _ret_var = ((ITextFont)wrapper).GetFontBitmapScalable();
 842             } catch (Exception e) {
 843                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 844                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 845             }
 846         return _ret_var;
 847         } else {
 848             return efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 849         }
 850     }
 851     private static efl_text_font_bitmap_scalable_get_delegate efl_text_font_bitmap_scalable_get_static_delegate;
 852
 853
 854      private delegate void efl_text_font_bitmap_scalable_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextFontBitmapScalable scalable);
 855
 856
 857      public delegate void efl_text_font_bitmap_scalable_set_api_delegate(System.IntPtr obj,   Efl.TextFontBitmapScalable scalable);
 858      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");
 859      private static void font_bitmap_scalable_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontBitmapScalable scalable)
 860     {
 861         Eina.Log.Debug("function efl_text_font_bitmap_scalable_set was called");
 862         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 863         if(wrapper != null) {
 864
 865             try {
 866                 ((ITextFont)wrapper).SetFontBitmapScalable( scalable);
 867             } catch (Exception e) {
 868                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 869                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 870             }
 871                                 } else {
 872             efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scalable);
 873         }
 874     }
 875     private static efl_text_font_bitmap_scalable_set_delegate efl_text_font_bitmap_scalable_set_static_delegate;
 876 }
 877 }
 878 namespace Efl {
 879 /// <summary>Type of font weight</summary>
 880 public enum TextFontWeight
 881 {
 882 /// <summary>Normal font weight</summary>
 883 Normal = 0,
 884 /// <summary>Thin font weight</summary>
 885 Thin = 1,
 886 /// <summary>Ultralight font weight</summary>
 887 Ultralight = 2,
 888 /// <summary>Extralight font weight</summary>
 889 Extralight = 3,
 890 /// <summary>Light font weight</summary>
 891 Light = 4,
 892 /// <summary>Book font weight</summary>
 893 Book = 5,
 894 /// <summary>Medium font weight</summary>
 895 Medium = 6,
 896 /// <summary>Semibold font weight</summary>
 897 Semibold = 7,
 898 /// <summary>Bold font weight</summary>
 899 Bold = 8,
 900 /// <summary>Ultrabold font weight</summary>
 901 Ultrabold = 9,
 902 /// <summary>Extrabold font weight</summary>
 903 Extrabold = 10,
 904 /// <summary>Black font weight</summary>
 905 Black = 11,
 906 /// <summary>Extrablack font weight</summary>
 907 Extrablack = 12,
 908 }
 909 }
 910 namespace Efl {
 911 /// <summary>Type of font width</summary>
 912 public enum TextFontWidth
 913 {
 914 /// <summary>Normal font width</summary>
 915 Normal = 0,
 916 /// <summary>Ultracondensed font width</summary>
 917 Ultracondensed = 1,
 918 /// <summary>Extracondensed font width</summary>
 919 Extracondensed = 2,
 920 /// <summary>Condensed font width</summary>
 921 Condensed = 3,
 922 /// <summary>Semicondensed font width</summary>
 923 Semicondensed = 4,
 924 /// <summary>Semiexpanded font width</summary>
 925 Semiexpanded = 5,
 926 /// <summary>Expanded font width</summary>
 927 Expanded = 6,
 928 /// <summary>Extraexpanded font width</summary>
 929 Extraexpanded = 7,
 930 /// <summary>Ultraexpanded font width</summary>
 931 Ultraexpanded = 8,
 932 }
 933 }
 934 namespace Efl {
 935 /// <summary>Type of font slant</summary>
 936 public enum TextFontSlant
 937 {
 938 /// <summary>Normal font slant</summary>
 939 Normal = 0,
 940 /// <summary>Oblique font slant</summary>
 941 Oblique = 1,
 942 /// <summary>Italic font slant</summary>
 943 Italic = 2,
 944 }
 945 }
 946 namespace Efl {
 947 /// <summary>Scalable of bitmap fonts</summary>
 948 public enum TextFontBitmapScalable
 949 {
 950 /// <summary>Disable scalable feature for bitmap fonts.</summary>
 951 None = 0,
 952 /// <summary>Enable scalable feature for color bitmap fonts.</summary>
 953 Color = 1,
 954 }
 955 }