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