internals/src/EflSharp/EflSharp/efl/efl_text_style.eo.cs

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 /// <summary>Style to apply to the text
  12 /// A style can be coloring, effects, underline, strikethrough etc.</summary>
  13 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  14 [Efl.ITextStyleConcrete.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public interface ITextStyle :
  17     Efl.Eo.IWrapper, IDisposable
  18 {
  19     /// <summary>Color of text, excluding style</summary>
  20 /// <param name="r">Red component</param>
  21 /// <param name="g">Green component</param>
  22 /// <param name="b">Blue component</param>
  23 /// <param name="a">Alpha component</param>
  24 void GetNormalColor(out byte r, out byte g, out byte b, out byte a);
  25     /// <summary>Color of text, excluding style</summary>
  26 /// <param name="r">Red component</param>
  27 /// <param name="g">Green component</param>
  28 /// <param name="b">Blue component</param>
  29 /// <param name="a">Alpha component</param>
  30 void SetNormalColor(byte r, byte g, byte b, byte a);
  31     /// <summary>Enable or disable backing type</summary>
  32 /// <returns>Backing type</returns>
  33 Efl.TextStyleBackingType GetBackingType();
  34     /// <summary>Enable or disable backing type</summary>
  35 /// <param name="type">Backing type</param>
  36 void SetBackingType(Efl.TextStyleBackingType type);
  37     /// <summary>Backing color</summary>
  38 /// <param name="r">Red component</param>
  39 /// <param name="g">Green component</param>
  40 /// <param name="b">Blue component</param>
  41 /// <param name="a">Alpha component</param>
  42 void GetBackingColor(out byte r, out byte g, out byte b, out byte a);
  43     /// <summary>Backing color</summary>
  44 /// <param name="r">Red component</param>
  45 /// <param name="g">Green component</param>
  46 /// <param name="b">Blue component</param>
  47 /// <param name="a">Alpha component</param>
  48 void SetBackingColor(byte r, byte g, byte b, byte a);
  49     /// <summary>Sets an underline style on the text</summary>
  50 /// <returns>Underline type</returns>
  51 Efl.TextStyleUnderlineType GetUnderlineType();
  52     /// <summary>Sets an underline style on the text</summary>
  53 /// <param name="type">Underline type</param>
  54 void SetUnderlineType(Efl.TextStyleUnderlineType type);
  55     /// <summary>Color of normal underline style</summary>
  56 /// <param name="r">Red component</param>
  57 /// <param name="g">Green component</param>
  58 /// <param name="b">Blue component</param>
  59 /// <param name="a">Alpha component</param>
  60 void GetUnderlineColor(out byte r, out byte g, out byte b, out byte a);
  61     /// <summary>Color of normal underline style</summary>
  62 /// <param name="r">Red component</param>
  63 /// <param name="g">Green component</param>
  64 /// <param name="b">Blue component</param>
  65 /// <param name="a">Alpha component</param>
  66 void SetUnderlineColor(byte r, byte g, byte b, byte a);
  67     /// <summary>Height of underline style</summary>
  68 /// <returns>Height</returns>
  69 double GetUnderlineHeight();
  70     /// <summary>Height of underline style</summary>
  71 /// <param name="height">Height</param>
  72 void SetUnderlineHeight(double height);
  73     /// <summary>Color of dashed underline style</summary>
  74 /// <param name="r">Red component</param>
  75 /// <param name="g">Green component</param>
  76 /// <param name="b">Blue component</param>
  77 /// <param name="a">Alpha component</param>
  78 void GetUnderlineDashedColor(out byte r, out byte g, out byte b, out byte a);
  79     /// <summary>Color of dashed underline style</summary>
  80 /// <param name="r">Red component</param>
  81 /// <param name="g">Green component</param>
  82 /// <param name="b">Blue component</param>
  83 /// <param name="a">Alpha component</param>
  84 void SetUnderlineDashedColor(byte r, byte g, byte b, byte a);
  85     /// <summary>Width of dashed underline style</summary>
  86 /// <returns>Width</returns>
  87 int GetUnderlineDashedWidth();
  88     /// <summary>Width of dashed underline style</summary>
  89 /// <param name="width">Width</param>
  90 void SetUnderlineDashedWidth(int width);
  91     /// <summary>Gap of dashed underline style</summary>
  92 /// <returns>Gap</returns>
  93 int GetUnderlineDashedGap();
  94     /// <summary>Gap of dashed underline style</summary>
  95 /// <param name="gap">Gap</param>
  96 void SetUnderlineDashedGap(int gap);
  97     /// <summary>Color of underline2 style</summary>
  98 /// <param name="r">Red component</param>
  99 /// <param name="g">Green component</param>
 100 /// <param name="b">Blue component</param>
 101 /// <param name="a">Alpha component</param>
 102 void GetUnderline2Color(out byte r, out byte g, out byte b, out byte a);
 103     /// <summary>Color of underline2 style</summary>
 104 /// <param name="r">Red component</param>
 105 /// <param name="g">Green component</param>
 106 /// <param name="b">Blue component</param>
 107 /// <param name="a">Alpha component</param>
 108 void SetUnderline2Color(byte r, byte g, byte b, byte a);
 109     /// <summary>Type of strikethrough style</summary>
 110 /// <returns>Strikethrough type</returns>
 111 Efl.TextStyleStrikethroughType GetStrikethroughType();
 112     /// <summary>Type of strikethrough style</summary>
 113 /// <param name="type">Strikethrough type</param>
 114 void SetStrikethroughType(Efl.TextStyleStrikethroughType type);
 115     /// <summary>Color of strikethrough_style</summary>
 116 /// <param name="r">Red component</param>
 117 /// <param name="g">Green component</param>
 118 /// <param name="b">Blue component</param>
 119 /// <param name="a">Alpha component</param>
 120 void GetStrikethroughColor(out byte r, out byte g, out byte b, out byte a);
 121     /// <summary>Color of strikethrough_style</summary>
 122 /// <param name="r">Red component</param>
 123 /// <param name="g">Green component</param>
 124 /// <param name="b">Blue component</param>
 125 /// <param name="a">Alpha component</param>
 126 void SetStrikethroughColor(byte r, byte g, byte b, byte a);
 127     /// <summary>Type of effect used for the displayed text</summary>
 128 /// <returns>Effect type</returns>
 129 Efl.TextStyleEffectType GetEffectType();
 130     /// <summary>Type of effect used for the displayed text</summary>
 131 /// <param name="type">Effect type</param>
 132 void SetEffectType(Efl.TextStyleEffectType type);
 133     /// <summary>Color of outline effect</summary>
 134 /// <param name="r">Red component</param>
 135 /// <param name="g">Green component</param>
 136 /// <param name="b">Blue component</param>
 137 /// <param name="a">Alpha component</param>
 138 void GetOutlineColor(out byte r, out byte g, out byte b, out byte a);
 139     /// <summary>Color of outline effect</summary>
 140 /// <param name="r">Red component</param>
 141 /// <param name="g">Green component</param>
 142 /// <param name="b">Blue component</param>
 143 /// <param name="a">Alpha component</param>
 144 void SetOutlineColor(byte r, byte g, byte b, byte a);
 145     /// <summary>Direction of shadow effect</summary>
 146 /// <returns>Shadow direction</returns>
 147 Efl.TextStyleShadowDirection GetShadowDirection();
 148     /// <summary>Direction of shadow effect</summary>
 149 /// <param name="type">Shadow direction</param>
 150 void SetShadowDirection(Efl.TextStyleShadowDirection type);
 151     /// <summary>Color of shadow effect</summary>
 152 /// <param name="r">Red component</param>
 153 /// <param name="g">Green component</param>
 154 /// <param name="b">Blue component</param>
 155 /// <param name="a">Alpha component</param>
 156 void GetShadowColor(out byte r, out byte g, out byte b, out byte a);
 157     /// <summary>Color of shadow effect</summary>
 158 /// <param name="r">Red component</param>
 159 /// <param name="g">Green component</param>
 160 /// <param name="b">Blue component</param>
 161 /// <param name="a">Alpha component</param>
 162 void SetShadowColor(byte r, byte g, byte b, byte a);
 163     /// <summary>Color of glow effect</summary>
 164 /// <param name="r">Red component</param>
 165 /// <param name="g">Green component</param>
 166 /// <param name="b">Blue component</param>
 167 /// <param name="a">Alpha component</param>
 168 void GetGlowColor(out byte r, out byte g, out byte b, out byte a);
 169     /// <summary>Color of glow effect</summary>
 170 /// <param name="r">Red component</param>
 171 /// <param name="g">Green component</param>
 172 /// <param name="b">Blue component</param>
 173 /// <param name="a">Alpha component</param>
 174 void SetGlowColor(byte r, byte g, byte b, byte a);
 175     /// <summary>Second color of the glow effect</summary>
 176 /// <param name="r">Red component</param>
 177 /// <param name="g">Green component</param>
 178 /// <param name="b">Blue component</param>
 179 /// <param name="a">Alpha component</param>
 180 void GetGlow2Color(out byte r, out byte g, out byte b, out byte a);
 181     /// <summary>Second color of the glow effect</summary>
 182 /// <param name="r">Red component</param>
 183 /// <param name="g">Green component</param>
 184 /// <param name="b">Blue component</param>
 185 /// <param name="a">Alpha component</param>
 186 void SetGlow2Color(byte r, byte g, byte b, byte a);
 187     /// <summary>Program that applies a special filter
 188 /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 189 /// <returns>Filter code</returns>
 190 System.String GetGfxFilter();
 191     /// <summary>Program that applies a special filter
 192 /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 193 /// <param name="code">Filter code</param>
 194 void SetGfxFilter(System.String code);
 195                                                                                                                                                             /// <summary>Color of text, excluding style</summary>
 196     /// <value>Red component</value>
 197     (byte, byte, byte, byte) NormalColor {
 198         get;
 199         set;
 200     }
 201     /// <summary>Enable or disable backing type</summary>
 202     /// <value>Backing type</value>
 203     Efl.TextStyleBackingType BackingType {
 204         get;
 205         set;
 206     }
 207     /// <summary>Backing color</summary>
 208     /// <value>Red component</value>
 209     (byte, byte, byte, byte) BackingColor {
 210         get;
 211         set;
 212     }
 213     /// <summary>Sets an underline style on the text</summary>
 214     /// <value>Underline type</value>
 215     Efl.TextStyleUnderlineType UnderlineType {
 216         get;
 217         set;
 218     }
 219     /// <summary>Color of normal underline style</summary>
 220     /// <value>Red component</value>
 221     (byte, byte, byte, byte) UnderlineColor {
 222         get;
 223         set;
 224     }
 225     /// <summary>Height of underline style</summary>
 226     /// <value>Height</value>
 227     double UnderlineHeight {
 228         get;
 229         set;
 230     }
 231     /// <summary>Color of dashed underline style</summary>
 232     /// <value>Red component</value>
 233     (byte, byte, byte, byte) UnderlineDashedColor {
 234         get;
 235         set;
 236     }
 237     /// <summary>Width of dashed underline style</summary>
 238     /// <value>Width</value>
 239     int UnderlineDashedWidth {
 240         get;
 241         set;
 242     }
 243     /// <summary>Gap of dashed underline style</summary>
 244     /// <value>Gap</value>
 245     int UnderlineDashedGap {
 246         get;
 247         set;
 248     }
 249     /// <summary>Color of underline2 style</summary>
 250     /// <value>Red component</value>
 251     (byte, byte, byte, byte) Underline2Color {
 252         get;
 253         set;
 254     }
 255     /// <summary>Type of strikethrough style</summary>
 256     /// <value>Strikethrough type</value>
 257     Efl.TextStyleStrikethroughType StrikethroughType {
 258         get;
 259         set;
 260     }
 261     /// <summary>Color of strikethrough_style</summary>
 262     /// <value>Red component</value>
 263     (byte, byte, byte, byte) StrikethroughColor {
 264         get;
 265         set;
 266     }
 267     /// <summary>Type of effect used for the displayed text</summary>
 268     /// <value>Effect type</value>
 269     Efl.TextStyleEffectType EffectType {
 270         get;
 271         set;
 272     }
 273     /// <summary>Color of outline effect</summary>
 274     /// <value>Red component</value>
 275     (byte, byte, byte, byte) OutlineColor {
 276         get;
 277         set;
 278     }
 279     /// <summary>Direction of shadow effect</summary>
 280     /// <value>Shadow direction</value>
 281     Efl.TextStyleShadowDirection ShadowDirection {
 282         get;
 283         set;
 284     }
 285     /// <summary>Color of shadow effect</summary>
 286     /// <value>Red component</value>
 287     (byte, byte, byte, byte) ShadowColor {
 288         get;
 289         set;
 290     }
 291     /// <summary>Color of glow effect</summary>
 292     /// <value>Red component</value>
 293     (byte, byte, byte, byte) GlowColor {
 294         get;
 295         set;
 296     }
 297     /// <summary>Second color of the glow effect</summary>
 298     /// <value>Red component</value>
 299     (byte, byte, byte, byte) Glow2Color {
 300         get;
 301         set;
 302     }
 303     /// <summary>Program that applies a special filter
 304     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 305     /// <value>Filter code</value>
 306     System.String GfxFilter {
 307         get;
 308         set;
 309     }
 310 }
 311 /// <summary>Style to apply to the text
 312 /// A style can be coloring, effects, underline, strikethrough etc.</summary>
 313 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
 314 sealed public  class ITextStyleConcrete :
 315     Efl.Eo.EoWrapper
 316     , ITextStyle
 317
 318 {
 319     /// <summary>Pointer to the native class description.</summary>
 320     public override System.IntPtr NativeClass
 321     {
 322         get
 323         {
 324             if (((object)this).GetType() == typeof(ITextStyleConcrete))
 325             {
 326                 return GetEflClassStatic();
 327             }
 328             else
 329             {
 330                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 331             }
 332         }
 333     }
 334
 335     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
 336     /// Do not call this constructor directly.</summary>
 337     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 338     private ITextStyleConcrete(ConstructingHandle ch) : base(ch)
 339     {
 340     }
 341
 342     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 343         efl_text_style_interface_get();
 344     /// <summary>Initializes a new instance of the <see cref="ITextStyle"/> class.
 345     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 346     /// <param name="wh">The native pointer to be wrapped.</param>
 347     private ITextStyleConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 348     {
 349     }
 350
 351     /// <summary>Color of text, excluding style</summary>
 352     /// <param name="r">Red component</param>
 353     /// <param name="g">Green component</param>
 354     /// <param name="b">Blue component</param>
 355     /// <param name="a">Alpha component</param>
 356     public void GetNormalColor(out byte r, out byte g, out byte b, out byte a) {
 357                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 358         Eina.Error.RaiseIfUnhandledException();
 359                                                                          }
 360     /// <summary>Color of text, excluding style</summary>
 361     /// <param name="r">Red component</param>
 362     /// <param name="g">Green component</param>
 363     /// <param name="b">Blue component</param>
 364     /// <param name="a">Alpha component</param>
 365     public void SetNormalColor(byte r, byte g, byte b, byte a) {
 366                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 367         Eina.Error.RaiseIfUnhandledException();
 368                                                                          }
 369     /// <summary>Enable or disable backing type</summary>
 370     /// <returns>Backing type</returns>
 371     public Efl.TextStyleBackingType GetBackingType() {
 372          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_get_ptr.Value.Delegate(this.NativeHandle);
 373         Eina.Error.RaiseIfUnhandledException();
 374         return _ret_var;
 375  }
 376     /// <summary>Enable or disable backing type</summary>
 377     /// <param name="type">Backing type</param>
 378     public void SetBackingType(Efl.TextStyleBackingType type) {
 379                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 380         Eina.Error.RaiseIfUnhandledException();
 381                          }
 382     /// <summary>Backing color</summary>
 383     /// <param name="r">Red component</param>
 384     /// <param name="g">Green component</param>
 385     /// <param name="b">Blue component</param>
 386     /// <param name="a">Alpha component</param>
 387     public void GetBackingColor(out byte r, out byte g, out byte b, out byte a) {
 388                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 389         Eina.Error.RaiseIfUnhandledException();
 390                                                                          }
 391     /// <summary>Backing color</summary>
 392     /// <param name="r">Red component</param>
 393     /// <param name="g">Green component</param>
 394     /// <param name="b">Blue component</param>
 395     /// <param name="a">Alpha component</param>
 396     public void SetBackingColor(byte r, byte g, byte b, byte a) {
 397                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 398         Eina.Error.RaiseIfUnhandledException();
 399                                                                          }
 400     /// <summary>Sets an underline style on the text</summary>
 401     /// <returns>Underline type</returns>
 402     public Efl.TextStyleUnderlineType GetUnderlineType() {
 403          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_get_ptr.Value.Delegate(this.NativeHandle);
 404         Eina.Error.RaiseIfUnhandledException();
 405         return _ret_var;
 406  }
 407     /// <summary>Sets an underline style on the text</summary>
 408     /// <param name="type">Underline type</param>
 409     public void SetUnderlineType(Efl.TextStyleUnderlineType type) {
 410                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 411         Eina.Error.RaiseIfUnhandledException();
 412                          }
 413     /// <summary>Color of normal underline style</summary>
 414     /// <param name="r">Red component</param>
 415     /// <param name="g">Green component</param>
 416     /// <param name="b">Blue component</param>
 417     /// <param name="a">Alpha component</param>
 418     public void GetUnderlineColor(out byte r, out byte g, out byte b, out byte a) {
 419                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 420         Eina.Error.RaiseIfUnhandledException();
 421                                                                          }
 422     /// <summary>Color of normal underline style</summary>
 423     /// <param name="r">Red component</param>
 424     /// <param name="g">Green component</param>
 425     /// <param name="b">Blue component</param>
 426     /// <param name="a">Alpha component</param>
 427     public void SetUnderlineColor(byte r, byte g, byte b, byte a) {
 428                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 429         Eina.Error.RaiseIfUnhandledException();
 430                                                                          }
 431     /// <summary>Height of underline style</summary>
 432     /// <returns>Height</returns>
 433     public double GetUnderlineHeight() {
 434          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_get_ptr.Value.Delegate(this.NativeHandle);
 435         Eina.Error.RaiseIfUnhandledException();
 436         return _ret_var;
 437  }
 438     /// <summary>Height of underline style</summary>
 439     /// <param name="height">Height</param>
 440     public void SetUnderlineHeight(double height) {
 441                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_set_ptr.Value.Delegate(this.NativeHandle,height);
 442         Eina.Error.RaiseIfUnhandledException();
 443                          }
 444     /// <summary>Color of dashed underline style</summary>
 445     /// <param name="r">Red component</param>
 446     /// <param name="g">Green component</param>
 447     /// <param name="b">Blue component</param>
 448     /// <param name="a">Alpha component</param>
 449     public void GetUnderlineDashedColor(out byte r, out byte g, out byte b, out byte a) {
 450                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 451         Eina.Error.RaiseIfUnhandledException();
 452                                                                          }
 453     /// <summary>Color of dashed underline style</summary>
 454     /// <param name="r">Red component</param>
 455     /// <param name="g">Green component</param>
 456     /// <param name="b">Blue component</param>
 457     /// <param name="a">Alpha component</param>
 458     public void SetUnderlineDashedColor(byte r, byte g, byte b, byte a) {
 459                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 460         Eina.Error.RaiseIfUnhandledException();
 461                                                                          }
 462     /// <summary>Width of dashed underline style</summary>
 463     /// <returns>Width</returns>
 464     public int GetUnderlineDashedWidth() {
 465          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_get_ptr.Value.Delegate(this.NativeHandle);
 466         Eina.Error.RaiseIfUnhandledException();
 467         return _ret_var;
 468  }
 469     /// <summary>Width of dashed underline style</summary>
 470     /// <param name="width">Width</param>
 471     public void SetUnderlineDashedWidth(int width) {
 472                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_set_ptr.Value.Delegate(this.NativeHandle,width);
 473         Eina.Error.RaiseIfUnhandledException();
 474                          }
 475     /// <summary>Gap of dashed underline style</summary>
 476     /// <returns>Gap</returns>
 477     public int GetUnderlineDashedGap() {
 478          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_get_ptr.Value.Delegate(this.NativeHandle);
 479         Eina.Error.RaiseIfUnhandledException();
 480         return _ret_var;
 481  }
 482     /// <summary>Gap of dashed underline style</summary>
 483     /// <param name="gap">Gap</param>
 484     public void SetUnderlineDashedGap(int gap) {
 485                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_set_ptr.Value.Delegate(this.NativeHandle,gap);
 486         Eina.Error.RaiseIfUnhandledException();
 487                          }
 488     /// <summary>Color of underline2 style</summary>
 489     /// <param name="r">Red component</param>
 490     /// <param name="g">Green component</param>
 491     /// <param name="b">Blue component</param>
 492     /// <param name="a">Alpha component</param>
 493     public void GetUnderline2Color(out byte r, out byte g, out byte b, out byte a) {
 494                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 495         Eina.Error.RaiseIfUnhandledException();
 496                                                                          }
 497     /// <summary>Color of underline2 style</summary>
 498     /// <param name="r">Red component</param>
 499     /// <param name="g">Green component</param>
 500     /// <param name="b">Blue component</param>
 501     /// <param name="a">Alpha component</param>
 502     public void SetUnderline2Color(byte r, byte g, byte b, byte a) {
 503                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 504         Eina.Error.RaiseIfUnhandledException();
 505                                                                          }
 506     /// <summary>Type of strikethrough style</summary>
 507     /// <returns>Strikethrough type</returns>
 508     public Efl.TextStyleStrikethroughType GetStrikethroughType() {
 509          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_get_ptr.Value.Delegate(this.NativeHandle);
 510         Eina.Error.RaiseIfUnhandledException();
 511         return _ret_var;
 512  }
 513     /// <summary>Type of strikethrough style</summary>
 514     /// <param name="type">Strikethrough type</param>
 515     public void SetStrikethroughType(Efl.TextStyleStrikethroughType type) {
 516                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 517         Eina.Error.RaiseIfUnhandledException();
 518                          }
 519     /// <summary>Color of strikethrough_style</summary>
 520     /// <param name="r">Red component</param>
 521     /// <param name="g">Green component</param>
 522     /// <param name="b">Blue component</param>
 523     /// <param name="a">Alpha component</param>
 524     public void GetStrikethroughColor(out byte r, out byte g, out byte b, out byte a) {
 525                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 526         Eina.Error.RaiseIfUnhandledException();
 527                                                                          }
 528     /// <summary>Color of strikethrough_style</summary>
 529     /// <param name="r">Red component</param>
 530     /// <param name="g">Green component</param>
 531     /// <param name="b">Blue component</param>
 532     /// <param name="a">Alpha component</param>
 533     public void SetStrikethroughColor(byte r, byte g, byte b, byte a) {
 534                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 535         Eina.Error.RaiseIfUnhandledException();
 536                                                                          }
 537     /// <summary>Type of effect used for the displayed text</summary>
 538     /// <returns>Effect type</returns>
 539     public Efl.TextStyleEffectType GetEffectType() {
 540          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_get_ptr.Value.Delegate(this.NativeHandle);
 541         Eina.Error.RaiseIfUnhandledException();
 542         return _ret_var;
 543  }
 544     /// <summary>Type of effect used for the displayed text</summary>
 545     /// <param name="type">Effect type</param>
 546     public void SetEffectType(Efl.TextStyleEffectType type) {
 547                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 548         Eina.Error.RaiseIfUnhandledException();
 549                          }
 550     /// <summary>Color of outline effect</summary>
 551     /// <param name="r">Red component</param>
 552     /// <param name="g">Green component</param>
 553     /// <param name="b">Blue component</param>
 554     /// <param name="a">Alpha component</param>
 555     public void GetOutlineColor(out byte r, out byte g, out byte b, out byte a) {
 556                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 557         Eina.Error.RaiseIfUnhandledException();
 558                                                                          }
 559     /// <summary>Color of outline effect</summary>
 560     /// <param name="r">Red component</param>
 561     /// <param name="g">Green component</param>
 562     /// <param name="b">Blue component</param>
 563     /// <param name="a">Alpha component</param>
 564     public void SetOutlineColor(byte r, byte g, byte b, byte a) {
 565                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 566         Eina.Error.RaiseIfUnhandledException();
 567                                                                          }
 568     /// <summary>Direction of shadow effect</summary>
 569     /// <returns>Shadow direction</returns>
 570     public Efl.TextStyleShadowDirection GetShadowDirection() {
 571          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_get_ptr.Value.Delegate(this.NativeHandle);
 572         Eina.Error.RaiseIfUnhandledException();
 573         return _ret_var;
 574  }
 575     /// <summary>Direction of shadow effect</summary>
 576     /// <param name="type">Shadow direction</param>
 577     public void SetShadowDirection(Efl.TextStyleShadowDirection type) {
 578                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_set_ptr.Value.Delegate(this.NativeHandle,type);
 579         Eina.Error.RaiseIfUnhandledException();
 580                          }
 581     /// <summary>Color of shadow effect</summary>
 582     /// <param name="r">Red component</param>
 583     /// <param name="g">Green component</param>
 584     /// <param name="b">Blue component</param>
 585     /// <param name="a">Alpha component</param>
 586     public void GetShadowColor(out byte r, out byte g, out byte b, out byte a) {
 587                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 588         Eina.Error.RaiseIfUnhandledException();
 589                                                                          }
 590     /// <summary>Color of shadow effect</summary>
 591     /// <param name="r">Red component</param>
 592     /// <param name="g">Green component</param>
 593     /// <param name="b">Blue component</param>
 594     /// <param name="a">Alpha component</param>
 595     public void SetShadowColor(byte r, byte g, byte b, byte a) {
 596                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 597         Eina.Error.RaiseIfUnhandledException();
 598                                                                          }
 599     /// <summary>Color of glow effect</summary>
 600     /// <param name="r">Red component</param>
 601     /// <param name="g">Green component</param>
 602     /// <param name="b">Blue component</param>
 603     /// <param name="a">Alpha component</param>
 604     public void GetGlowColor(out byte r, out byte g, out byte b, out byte a) {
 605                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 606         Eina.Error.RaiseIfUnhandledException();
 607                                                                          }
 608     /// <summary>Color of glow effect</summary>
 609     /// <param name="r">Red component</param>
 610     /// <param name="g">Green component</param>
 611     /// <param name="b">Blue component</param>
 612     /// <param name="a">Alpha component</param>
 613     public void SetGlowColor(byte r, byte g, byte b, byte a) {
 614                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 615         Eina.Error.RaiseIfUnhandledException();
 616                                                                          }
 617     /// <summary>Second color of the glow effect</summary>
 618     /// <param name="r">Red component</param>
 619     /// <param name="g">Green component</param>
 620     /// <param name="b">Blue component</param>
 621     /// <param name="a">Alpha component</param>
 622     public void GetGlow2Color(out byte r, out byte g, out byte b, out byte a) {
 623                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 624         Eina.Error.RaiseIfUnhandledException();
 625                                                                          }
 626     /// <summary>Second color of the glow effect</summary>
 627     /// <param name="r">Red component</param>
 628     /// <param name="g">Green component</param>
 629     /// <param name="b">Blue component</param>
 630     /// <param name="a">Alpha component</param>
 631     public void SetGlow2Color(byte r, byte g, byte b, byte a) {
 632                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 633         Eina.Error.RaiseIfUnhandledException();
 634                                                                          }
 635     /// <summary>Program that applies a special filter
 636     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 637     /// <returns>Filter code</returns>
 638     public System.String GetGfxFilter() {
 639          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_get_ptr.Value.Delegate(this.NativeHandle);
 640         Eina.Error.RaiseIfUnhandledException();
 641         return _ret_var;
 642  }
 643     /// <summary>Program that applies a special filter
 644     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 645     /// <param name="code">Filter code</param>
 646     public void SetGfxFilter(System.String code) {
 647                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_set_ptr.Value.Delegate(this.NativeHandle,code);
 648         Eina.Error.RaiseIfUnhandledException();
 649                          }
 650     /// <summary>Color of text, excluding style</summary>
 651     /// <value>Red component</value>
 652     public (byte, byte, byte, byte) NormalColor {
 653         get {
 654             byte _out_r = default(byte);
 655             byte _out_g = default(byte);
 656             byte _out_b = default(byte);
 657             byte _out_a = default(byte);
 658             GetNormalColor(out _out_r,out _out_g,out _out_b,out _out_a);
 659             return (_out_r,_out_g,_out_b,_out_a);
 660         }
 661         set { SetNormalColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 662     }
 663     /// <summary>Enable or disable backing type</summary>
 664     /// <value>Backing type</value>
 665     public Efl.TextStyleBackingType BackingType {
 666         get { return GetBackingType(); }
 667         set { SetBackingType(value); }
 668     }
 669     /// <summary>Backing color</summary>
 670     /// <value>Red component</value>
 671     public (byte, byte, byte, byte) BackingColor {
 672         get {
 673             byte _out_r = default(byte);
 674             byte _out_g = default(byte);
 675             byte _out_b = default(byte);
 676             byte _out_a = default(byte);
 677             GetBackingColor(out _out_r,out _out_g,out _out_b,out _out_a);
 678             return (_out_r,_out_g,_out_b,_out_a);
 679         }
 680         set { SetBackingColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 681     }
 682     /// <summary>Sets an underline style on the text</summary>
 683     /// <value>Underline type</value>
 684     public Efl.TextStyleUnderlineType UnderlineType {
 685         get { return GetUnderlineType(); }
 686         set { SetUnderlineType(value); }
 687     }
 688     /// <summary>Color of normal underline style</summary>
 689     /// <value>Red component</value>
 690     public (byte, byte, byte, byte) UnderlineColor {
 691         get {
 692             byte _out_r = default(byte);
 693             byte _out_g = default(byte);
 694             byte _out_b = default(byte);
 695             byte _out_a = default(byte);
 696             GetUnderlineColor(out _out_r,out _out_g,out _out_b,out _out_a);
 697             return (_out_r,_out_g,_out_b,_out_a);
 698         }
 699         set { SetUnderlineColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 700     }
 701     /// <summary>Height of underline style</summary>
 702     /// <value>Height</value>
 703     public double UnderlineHeight {
 704         get { return GetUnderlineHeight(); }
 705         set { SetUnderlineHeight(value); }
 706     }
 707     /// <summary>Color of dashed underline style</summary>
 708     /// <value>Red component</value>
 709     public (byte, byte, byte, byte) UnderlineDashedColor {
 710         get {
 711             byte _out_r = default(byte);
 712             byte _out_g = default(byte);
 713             byte _out_b = default(byte);
 714             byte _out_a = default(byte);
 715             GetUnderlineDashedColor(out _out_r,out _out_g,out _out_b,out _out_a);
 716             return (_out_r,_out_g,_out_b,_out_a);
 717         }
 718         set { SetUnderlineDashedColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 719     }
 720     /// <summary>Width of dashed underline style</summary>
 721     /// <value>Width</value>
 722     public int UnderlineDashedWidth {
 723         get { return GetUnderlineDashedWidth(); }
 724         set { SetUnderlineDashedWidth(value); }
 725     }
 726     /// <summary>Gap of dashed underline style</summary>
 727     /// <value>Gap</value>
 728     public int UnderlineDashedGap {
 729         get { return GetUnderlineDashedGap(); }
 730         set { SetUnderlineDashedGap(value); }
 731     }
 732     /// <summary>Color of underline2 style</summary>
 733     /// <value>Red component</value>
 734     public (byte, byte, byte, byte) Underline2Color {
 735         get {
 736             byte _out_r = default(byte);
 737             byte _out_g = default(byte);
 738             byte _out_b = default(byte);
 739             byte _out_a = default(byte);
 740             GetUnderline2Color(out _out_r,out _out_g,out _out_b,out _out_a);
 741             return (_out_r,_out_g,_out_b,_out_a);
 742         }
 743         set { SetUnderline2Color( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 744     }
 745     /// <summary>Type of strikethrough style</summary>
 746     /// <value>Strikethrough type</value>
 747     public Efl.TextStyleStrikethroughType StrikethroughType {
 748         get { return GetStrikethroughType(); }
 749         set { SetStrikethroughType(value); }
 750     }
 751     /// <summary>Color of strikethrough_style</summary>
 752     /// <value>Red component</value>
 753     public (byte, byte, byte, byte) StrikethroughColor {
 754         get {
 755             byte _out_r = default(byte);
 756             byte _out_g = default(byte);
 757             byte _out_b = default(byte);
 758             byte _out_a = default(byte);
 759             GetStrikethroughColor(out _out_r,out _out_g,out _out_b,out _out_a);
 760             return (_out_r,_out_g,_out_b,_out_a);
 761         }
 762         set { SetStrikethroughColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 763     }
 764     /// <summary>Type of effect used for the displayed text</summary>
 765     /// <value>Effect type</value>
 766     public Efl.TextStyleEffectType EffectType {
 767         get { return GetEffectType(); }
 768         set { SetEffectType(value); }
 769     }
 770     /// <summary>Color of outline effect</summary>
 771     /// <value>Red component</value>
 772     public (byte, byte, byte, byte) OutlineColor {
 773         get {
 774             byte _out_r = default(byte);
 775             byte _out_g = default(byte);
 776             byte _out_b = default(byte);
 777             byte _out_a = default(byte);
 778             GetOutlineColor(out _out_r,out _out_g,out _out_b,out _out_a);
 779             return (_out_r,_out_g,_out_b,_out_a);
 780         }
 781         set { SetOutlineColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 782     }
 783     /// <summary>Direction of shadow effect</summary>
 784     /// <value>Shadow direction</value>
 785     public Efl.TextStyleShadowDirection ShadowDirection {
 786         get { return GetShadowDirection(); }
 787         set { SetShadowDirection(value); }
 788     }
 789     /// <summary>Color of shadow effect</summary>
 790     /// <value>Red component</value>
 791     public (byte, byte, byte, byte) ShadowColor {
 792         get {
 793             byte _out_r = default(byte);
 794             byte _out_g = default(byte);
 795             byte _out_b = default(byte);
 796             byte _out_a = default(byte);
 797             GetShadowColor(out _out_r,out _out_g,out _out_b,out _out_a);
 798             return (_out_r,_out_g,_out_b,_out_a);
 799         }
 800         set { SetShadowColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 801     }
 802     /// <summary>Color of glow effect</summary>
 803     /// <value>Red component</value>
 804     public (byte, byte, byte, byte) GlowColor {
 805         get {
 806             byte _out_r = default(byte);
 807             byte _out_g = default(byte);
 808             byte _out_b = default(byte);
 809             byte _out_a = default(byte);
 810             GetGlowColor(out _out_r,out _out_g,out _out_b,out _out_a);
 811             return (_out_r,_out_g,_out_b,_out_a);
 812         }
 813         set { SetGlowColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 814     }
 815     /// <summary>Second color of the glow effect</summary>
 816     /// <value>Red component</value>
 817     public (byte, byte, byte, byte) Glow2Color {
 818         get {
 819             byte _out_r = default(byte);
 820             byte _out_g = default(byte);
 821             byte _out_b = default(byte);
 822             byte _out_a = default(byte);
 823             GetGlow2Color(out _out_r,out _out_g,out _out_b,out _out_a);
 824             return (_out_r,_out_g,_out_b,_out_a);
 825         }
 826         set { SetGlow2Color( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 827     }
 828     /// <summary>Program that applies a special filter
 829     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 830     /// <value>Filter code</value>
 831     public System.String GfxFilter {
 832         get { return GetGfxFilter(); }
 833         set { SetGfxFilter(value); }
 834     }
 835     private static IntPtr GetEflClassStatic()
 836     {
 837         return Efl.ITextStyleConcrete.efl_text_style_interface_get();
 838     }
 839     /// <summary>Wrapper for native methods and virtual method delegates.
 840     /// For internal use by generated code only.</summary>
 841     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 842     {
 843         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 844         /// <summary>Gets the list of Eo operations to override.</summary>
 845         /// <returns>The list of Eo operations to be overload.</returns>
 846         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 847         {
 848             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 849             var methods = Efl.Eo.Globals.GetUserMethods(type);
 850
 851             if (efl_text_normal_color_get_static_delegate == null)
 852             {
 853                 efl_text_normal_color_get_static_delegate = new efl_text_normal_color_get_delegate(normal_color_get);
 854             }
 855
 856             if (methods.FirstOrDefault(m => m.Name == "GetNormalColor") != null)
 857             {
 858                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_normal_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_normal_color_get_static_delegate) });
 859             }
 860
 861             if (efl_text_normal_color_set_static_delegate == null)
 862             {
 863                 efl_text_normal_color_set_static_delegate = new efl_text_normal_color_set_delegate(normal_color_set);
 864             }
 865
 866             if (methods.FirstOrDefault(m => m.Name == "SetNormalColor") != null)
 867             {
 868                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_normal_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_normal_color_set_static_delegate) });
 869             }
 870
 871             if (efl_text_backing_type_get_static_delegate == null)
 872             {
 873                 efl_text_backing_type_get_static_delegate = new efl_text_backing_type_get_delegate(backing_type_get);
 874             }
 875
 876             if (methods.FirstOrDefault(m => m.Name == "GetBackingType") != null)
 877             {
 878                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_backing_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_backing_type_get_static_delegate) });
 879             }
 880
 881             if (efl_text_backing_type_set_static_delegate == null)
 882             {
 883                 efl_text_backing_type_set_static_delegate = new efl_text_backing_type_set_delegate(backing_type_set);
 884             }
 885
 886             if (methods.FirstOrDefault(m => m.Name == "SetBackingType") != null)
 887             {
 888                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_backing_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_backing_type_set_static_delegate) });
 889             }
 890
 891             if (efl_text_backing_color_get_static_delegate == null)
 892             {
 893                 efl_text_backing_color_get_static_delegate = new efl_text_backing_color_get_delegate(backing_color_get);
 894             }
 895
 896             if (methods.FirstOrDefault(m => m.Name == "GetBackingColor") != null)
 897             {
 898                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_backing_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_backing_color_get_static_delegate) });
 899             }
 900
 901             if (efl_text_backing_color_set_static_delegate == null)
 902             {
 903                 efl_text_backing_color_set_static_delegate = new efl_text_backing_color_set_delegate(backing_color_set);
 904             }
 905
 906             if (methods.FirstOrDefault(m => m.Name == "SetBackingColor") != null)
 907             {
 908                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_backing_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_backing_color_set_static_delegate) });
 909             }
 910
 911             if (efl_text_underline_type_get_static_delegate == null)
 912             {
 913                 efl_text_underline_type_get_static_delegate = new efl_text_underline_type_get_delegate(underline_type_get);
 914             }
 915
 916             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineType") != null)
 917             {
 918                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_type_get_static_delegate) });
 919             }
 920
 921             if (efl_text_underline_type_set_static_delegate == null)
 922             {
 923                 efl_text_underline_type_set_static_delegate = new efl_text_underline_type_set_delegate(underline_type_set);
 924             }
 925
 926             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineType") != null)
 927             {
 928                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_type_set_static_delegate) });
 929             }
 930
 931             if (efl_text_underline_color_get_static_delegate == null)
 932             {
 933                 efl_text_underline_color_get_static_delegate = new efl_text_underline_color_get_delegate(underline_color_get);
 934             }
 935
 936             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineColor") != null)
 937             {
 938                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_color_get_static_delegate) });
 939             }
 940
 941             if (efl_text_underline_color_set_static_delegate == null)
 942             {
 943                 efl_text_underline_color_set_static_delegate = new efl_text_underline_color_set_delegate(underline_color_set);
 944             }
 945
 946             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineColor") != null)
 947             {
 948                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_color_set_static_delegate) });
 949             }
 950
 951             if (efl_text_underline_height_get_static_delegate == null)
 952             {
 953                 efl_text_underline_height_get_static_delegate = new efl_text_underline_height_get_delegate(underline_height_get);
 954             }
 955
 956             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineHeight") != null)
 957             {
 958                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_height_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_height_get_static_delegate) });
 959             }
 960
 961             if (efl_text_underline_height_set_static_delegate == null)
 962             {
 963                 efl_text_underline_height_set_static_delegate = new efl_text_underline_height_set_delegate(underline_height_set);
 964             }
 965
 966             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineHeight") != null)
 967             {
 968                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_height_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_height_set_static_delegate) });
 969             }
 970
 971             if (efl_text_underline_dashed_color_get_static_delegate == null)
 972             {
 973                 efl_text_underline_dashed_color_get_static_delegate = new efl_text_underline_dashed_color_get_delegate(underline_dashed_color_get);
 974             }
 975
 976             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedColor") != null)
 977             {
 978                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_color_get_static_delegate) });
 979             }
 980
 981             if (efl_text_underline_dashed_color_set_static_delegate == null)
 982             {
 983                 efl_text_underline_dashed_color_set_static_delegate = new efl_text_underline_dashed_color_set_delegate(underline_dashed_color_set);
 984             }
 985
 986             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedColor") != null)
 987             {
 988                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_color_set_static_delegate) });
 989             }
 990
 991             if (efl_text_underline_dashed_width_get_static_delegate == null)
 992             {
 993                 efl_text_underline_dashed_width_get_static_delegate = new efl_text_underline_dashed_width_get_delegate(underline_dashed_width_get);
 994             }
 995
 996             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedWidth") != null)
 997             {
 998                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_width_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_width_get_static_delegate) });
 999             }
1000
1001             if (efl_text_underline_dashed_width_set_static_delegate == null)
1002             {
1003                 efl_text_underline_dashed_width_set_static_delegate = new efl_text_underline_dashed_width_set_delegate(underline_dashed_width_set);
1004             }
1005
1006             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedWidth") != null)
1007             {
1008                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_width_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_width_set_static_delegate) });
1009             }
1010
1011             if (efl_text_underline_dashed_gap_get_static_delegate == null)
1012             {
1013                 efl_text_underline_dashed_gap_get_static_delegate = new efl_text_underline_dashed_gap_get_delegate(underline_dashed_gap_get);
1014             }
1015
1016             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedGap") != null)
1017             {
1018                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_gap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_gap_get_static_delegate) });
1019             }
1020
1021             if (efl_text_underline_dashed_gap_set_static_delegate == null)
1022             {
1023                 efl_text_underline_dashed_gap_set_static_delegate = new efl_text_underline_dashed_gap_set_delegate(underline_dashed_gap_set);
1024             }
1025
1026             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedGap") != null)
1027             {
1028                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline_dashed_gap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline_dashed_gap_set_static_delegate) });
1029             }
1030
1031             if (efl_text_underline2_color_get_static_delegate == null)
1032             {
1033                 efl_text_underline2_color_get_static_delegate = new efl_text_underline2_color_get_delegate(underline2_color_get);
1034             }
1035
1036             if (methods.FirstOrDefault(m => m.Name == "GetUnderline2Color") != null)
1037             {
1038                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline2_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline2_color_get_static_delegate) });
1039             }
1040
1041             if (efl_text_underline2_color_set_static_delegate == null)
1042             {
1043                 efl_text_underline2_color_set_static_delegate = new efl_text_underline2_color_set_delegate(underline2_color_set);
1044             }
1045
1046             if (methods.FirstOrDefault(m => m.Name == "SetUnderline2Color") != null)
1047             {
1048                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_underline2_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_underline2_color_set_static_delegate) });
1049             }
1050
1051             if (efl_text_strikethrough_type_get_static_delegate == null)
1052             {
1053                 efl_text_strikethrough_type_get_static_delegate = new efl_text_strikethrough_type_get_delegate(strikethrough_type_get);
1054             }
1055
1056             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughType") != null)
1057             {
1058                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_strikethrough_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_strikethrough_type_get_static_delegate) });
1059             }
1060
1061             if (efl_text_strikethrough_type_set_static_delegate == null)
1062             {
1063                 efl_text_strikethrough_type_set_static_delegate = new efl_text_strikethrough_type_set_delegate(strikethrough_type_set);
1064             }
1065
1066             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughType") != null)
1067             {
1068                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_strikethrough_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_strikethrough_type_set_static_delegate) });
1069             }
1070
1071             if (efl_text_strikethrough_color_get_static_delegate == null)
1072             {
1073                 efl_text_strikethrough_color_get_static_delegate = new efl_text_strikethrough_color_get_delegate(strikethrough_color_get);
1074             }
1075
1076             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughColor") != null)
1077             {
1078                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_strikethrough_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_strikethrough_color_get_static_delegate) });
1079             }
1080
1081             if (efl_text_strikethrough_color_set_static_delegate == null)
1082             {
1083                 efl_text_strikethrough_color_set_static_delegate = new efl_text_strikethrough_color_set_delegate(strikethrough_color_set);
1084             }
1085
1086             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughColor") != null)
1087             {
1088                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_strikethrough_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_strikethrough_color_set_static_delegate) });
1089             }
1090
1091             if (efl_text_effect_type_get_static_delegate == null)
1092             {
1093                 efl_text_effect_type_get_static_delegate = new efl_text_effect_type_get_delegate(effect_type_get);
1094             }
1095
1096             if (methods.FirstOrDefault(m => m.Name == "GetEffectType") != null)
1097             {
1098                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_effect_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_effect_type_get_static_delegate) });
1099             }
1100
1101             if (efl_text_effect_type_set_static_delegate == null)
1102             {
1103                 efl_text_effect_type_set_static_delegate = new efl_text_effect_type_set_delegate(effect_type_set);
1104             }
1105
1106             if (methods.FirstOrDefault(m => m.Name == "SetEffectType") != null)
1107             {
1108                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_effect_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_effect_type_set_static_delegate) });
1109             }
1110
1111             if (efl_text_outline_color_get_static_delegate == null)
1112             {
1113                 efl_text_outline_color_get_static_delegate = new efl_text_outline_color_get_delegate(outline_color_get);
1114             }
1115
1116             if (methods.FirstOrDefault(m => m.Name == "GetOutlineColor") != null)
1117             {
1118                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_outline_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_outline_color_get_static_delegate) });
1119             }
1120
1121             if (efl_text_outline_color_set_static_delegate == null)
1122             {
1123                 efl_text_outline_color_set_static_delegate = new efl_text_outline_color_set_delegate(outline_color_set);
1124             }
1125
1126             if (methods.FirstOrDefault(m => m.Name == "SetOutlineColor") != null)
1127             {
1128                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_outline_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_outline_color_set_static_delegate) });
1129             }
1130
1131             if (efl_text_shadow_direction_get_static_delegate == null)
1132             {
1133                 efl_text_shadow_direction_get_static_delegate = new efl_text_shadow_direction_get_delegate(shadow_direction_get);
1134             }
1135
1136             if (methods.FirstOrDefault(m => m.Name == "GetShadowDirection") != null)
1137             {
1138                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_shadow_direction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_shadow_direction_get_static_delegate) });
1139             }
1140
1141             if (efl_text_shadow_direction_set_static_delegate == null)
1142             {
1143                 efl_text_shadow_direction_set_static_delegate = new efl_text_shadow_direction_set_delegate(shadow_direction_set);
1144             }
1145
1146             if (methods.FirstOrDefault(m => m.Name == "SetShadowDirection") != null)
1147             {
1148                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_shadow_direction_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_shadow_direction_set_static_delegate) });
1149             }
1150
1151             if (efl_text_shadow_color_get_static_delegate == null)
1152             {
1153                 efl_text_shadow_color_get_static_delegate = new efl_text_shadow_color_get_delegate(shadow_color_get);
1154             }
1155
1156             if (methods.FirstOrDefault(m => m.Name == "GetShadowColor") != null)
1157             {
1158                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_shadow_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_shadow_color_get_static_delegate) });
1159             }
1160
1161             if (efl_text_shadow_color_set_static_delegate == null)
1162             {
1163                 efl_text_shadow_color_set_static_delegate = new efl_text_shadow_color_set_delegate(shadow_color_set);
1164             }
1165
1166             if (methods.FirstOrDefault(m => m.Name == "SetShadowColor") != null)
1167             {
1168                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_shadow_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_shadow_color_set_static_delegate) });
1169             }
1170
1171             if (efl_text_glow_color_get_static_delegate == null)
1172             {
1173                 efl_text_glow_color_get_static_delegate = new efl_text_glow_color_get_delegate(glow_color_get);
1174             }
1175
1176             if (methods.FirstOrDefault(m => m.Name == "GetGlowColor") != null)
1177             {
1178                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_glow_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_glow_color_get_static_delegate) });
1179             }
1180
1181             if (efl_text_glow_color_set_static_delegate == null)
1182             {
1183                 efl_text_glow_color_set_static_delegate = new efl_text_glow_color_set_delegate(glow_color_set);
1184             }
1185
1186             if (methods.FirstOrDefault(m => m.Name == "SetGlowColor") != null)
1187             {
1188                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_glow_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_glow_color_set_static_delegate) });
1189             }
1190
1191             if (efl_text_glow2_color_get_static_delegate == null)
1192             {
1193                 efl_text_glow2_color_get_static_delegate = new efl_text_glow2_color_get_delegate(glow2_color_get);
1194             }
1195
1196             if (methods.FirstOrDefault(m => m.Name == "GetGlow2Color") != null)
1197             {
1198                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_glow2_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_glow2_color_get_static_delegate) });
1199             }
1200
1201             if (efl_text_glow2_color_set_static_delegate == null)
1202             {
1203                 efl_text_glow2_color_set_static_delegate = new efl_text_glow2_color_set_delegate(glow2_color_set);
1204             }
1205
1206             if (methods.FirstOrDefault(m => m.Name == "SetGlow2Color") != null)
1207             {
1208                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_glow2_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_glow2_color_set_static_delegate) });
1209             }
1210
1211             if (efl_text_gfx_filter_get_static_delegate == null)
1212             {
1213                 efl_text_gfx_filter_get_static_delegate = new efl_text_gfx_filter_get_delegate(gfx_filter_get);
1214             }
1215
1216             if (methods.FirstOrDefault(m => m.Name == "GetGfxFilter") != null)
1217             {
1218                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_gfx_filter_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_gfx_filter_get_static_delegate) });
1219             }
1220
1221             if (efl_text_gfx_filter_set_static_delegate == null)
1222             {
1223                 efl_text_gfx_filter_set_static_delegate = new efl_text_gfx_filter_set_delegate(gfx_filter_set);
1224             }
1225
1226             if (methods.FirstOrDefault(m => m.Name == "SetGfxFilter") != null)
1227             {
1228                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_gfx_filter_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_gfx_filter_set_static_delegate) });
1229             }
1230
1231             return descs;
1232         }
1233         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1234         /// <returns>The native class pointer.</returns>
1235         public override IntPtr GetEflClass()
1236         {
1237             return Efl.ITextStyleConcrete.efl_text_style_interface_get();
1238         }
1239
1240         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1241
1242
1243         private delegate void efl_text_normal_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
1244
1245
1246         public delegate void efl_text_normal_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
1247
1248         public static Efl.Eo.FunctionWrapper<efl_text_normal_color_get_api_delegate> efl_text_normal_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_normal_color_get_api_delegate>(Module, "efl_text_normal_color_get");
1249
1250         private static void normal_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
1251         {
1252             Eina.Log.Debug("function efl_text_normal_color_get was called");
1253             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1254             if (ws != null)
1255             {
1256                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
1257                 try
1258                 {
1259                     ((ITextStyle)ws.Target).GetNormalColor(out r, out g, out b, out a);
1260                 }
1261                 catch (Exception e)
1262                 {
1263                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1264                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1265                 }
1266
1267
1268             }
1269             else
1270             {
1271                 efl_text_normal_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1272             }
1273         }
1274
1275         private static efl_text_normal_color_get_delegate efl_text_normal_color_get_static_delegate;
1276
1277
1278         private delegate void efl_text_normal_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
1279
1280
1281         public delegate void efl_text_normal_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
1282
1283         public static Efl.Eo.FunctionWrapper<efl_text_normal_color_set_api_delegate> efl_text_normal_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_normal_color_set_api_delegate>(Module, "efl_text_normal_color_set");
1284
1285         private static void normal_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
1286         {
1287             Eina.Log.Debug("function efl_text_normal_color_set was called");
1288             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1289             if (ws != null)
1290             {
1291
1292                 try
1293                 {
1294                     ((ITextStyle)ws.Target).SetNormalColor(r, g, b, a);
1295                 }
1296                 catch (Exception e)
1297                 {
1298                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1299                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1300                 }
1301
1302
1303             }
1304             else
1305             {
1306                 efl_text_normal_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1307             }
1308         }
1309
1310         private static efl_text_normal_color_set_delegate efl_text_normal_color_set_static_delegate;
1311
1312
1313         private delegate Efl.TextStyleBackingType efl_text_backing_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1314
1315
1316         public delegate Efl.TextStyleBackingType efl_text_backing_type_get_api_delegate(System.IntPtr obj);
1317
1318         public static Efl.Eo.FunctionWrapper<efl_text_backing_type_get_api_delegate> efl_text_backing_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_backing_type_get_api_delegate>(Module, "efl_text_backing_type_get");
1319
1320         private static Efl.TextStyleBackingType backing_type_get(System.IntPtr obj, System.IntPtr pd)
1321         {
1322             Eina.Log.Debug("function efl_text_backing_type_get was called");
1323             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1324             if (ws != null)
1325             {
1326             Efl.TextStyleBackingType _ret_var = default(Efl.TextStyleBackingType);
1327                 try
1328                 {
1329                     _ret_var = ((ITextStyle)ws.Target).GetBackingType();
1330                 }
1331                 catch (Exception e)
1332                 {
1333                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1334                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1335                 }
1336
1337         return _ret_var;
1338
1339             }
1340             else
1341             {
1342                 return efl_text_backing_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1343             }
1344         }
1345
1346         private static efl_text_backing_type_get_delegate efl_text_backing_type_get_static_delegate;
1347
1348
1349         private delegate void efl_text_backing_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleBackingType type);
1350
1351
1352         public delegate void efl_text_backing_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleBackingType type);
1353
1354         public static Efl.Eo.FunctionWrapper<efl_text_backing_type_set_api_delegate> efl_text_backing_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_backing_type_set_api_delegate>(Module, "efl_text_backing_type_set");
1355
1356         private static void backing_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleBackingType type)
1357         {
1358             Eina.Log.Debug("function efl_text_backing_type_set was called");
1359             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1360             if (ws != null)
1361             {
1362
1363                 try
1364                 {
1365                     ((ITextStyle)ws.Target).SetBackingType(type);
1366                 }
1367                 catch (Exception e)
1368                 {
1369                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1370                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1371                 }
1372
1373
1374             }
1375             else
1376             {
1377                 efl_text_backing_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
1378             }
1379         }
1380
1381         private static efl_text_backing_type_set_delegate efl_text_backing_type_set_static_delegate;
1382
1383
1384         private delegate void efl_text_backing_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
1385
1386
1387         public delegate void efl_text_backing_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
1388
1389         public static Efl.Eo.FunctionWrapper<efl_text_backing_color_get_api_delegate> efl_text_backing_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_backing_color_get_api_delegate>(Module, "efl_text_backing_color_get");
1390
1391         private static void backing_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
1392         {
1393             Eina.Log.Debug("function efl_text_backing_color_get was called");
1394             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1395             if (ws != null)
1396             {
1397                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
1398                 try
1399                 {
1400                     ((ITextStyle)ws.Target).GetBackingColor(out r, out g, out b, out a);
1401                 }
1402                 catch (Exception e)
1403                 {
1404                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1405                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1406                 }
1407
1408
1409             }
1410             else
1411             {
1412                 efl_text_backing_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1413             }
1414         }
1415
1416         private static efl_text_backing_color_get_delegate efl_text_backing_color_get_static_delegate;
1417
1418
1419         private delegate void efl_text_backing_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
1420
1421
1422         public delegate void efl_text_backing_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
1423
1424         public static Efl.Eo.FunctionWrapper<efl_text_backing_color_set_api_delegate> efl_text_backing_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_backing_color_set_api_delegate>(Module, "efl_text_backing_color_set");
1425
1426         private static void backing_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
1427         {
1428             Eina.Log.Debug("function efl_text_backing_color_set was called");
1429             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1430             if (ws != null)
1431             {
1432
1433                 try
1434                 {
1435                     ((ITextStyle)ws.Target).SetBackingColor(r, g, b, a);
1436                 }
1437                 catch (Exception e)
1438                 {
1439                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1440                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1441                 }
1442
1443
1444             }
1445             else
1446             {
1447                 efl_text_backing_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1448             }
1449         }
1450
1451         private static efl_text_backing_color_set_delegate efl_text_backing_color_set_static_delegate;
1452
1453
1454         private delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1455
1456
1457         public delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_api_delegate(System.IntPtr obj);
1458
1459         public static Efl.Eo.FunctionWrapper<efl_text_underline_type_get_api_delegate> efl_text_underline_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_type_get_api_delegate>(Module, "efl_text_underline_type_get");
1460
1461         private static Efl.TextStyleUnderlineType underline_type_get(System.IntPtr obj, System.IntPtr pd)
1462         {
1463             Eina.Log.Debug("function efl_text_underline_type_get was called");
1464             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1465             if (ws != null)
1466             {
1467             Efl.TextStyleUnderlineType _ret_var = default(Efl.TextStyleUnderlineType);
1468                 try
1469                 {
1470                     _ret_var = ((ITextStyle)ws.Target).GetUnderlineType();
1471                 }
1472                 catch (Exception e)
1473                 {
1474                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1475                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1476                 }
1477
1478         return _ret_var;
1479
1480             }
1481             else
1482             {
1483                 return efl_text_underline_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1484             }
1485         }
1486
1487         private static efl_text_underline_type_get_delegate efl_text_underline_type_get_static_delegate;
1488
1489
1490         private delegate void efl_text_underline_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleUnderlineType type);
1491
1492
1493         public delegate void efl_text_underline_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleUnderlineType type);
1494
1495         public static Efl.Eo.FunctionWrapper<efl_text_underline_type_set_api_delegate> efl_text_underline_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_type_set_api_delegate>(Module, "efl_text_underline_type_set");
1496
1497         private static void underline_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleUnderlineType type)
1498         {
1499             Eina.Log.Debug("function efl_text_underline_type_set was called");
1500             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1501             if (ws != null)
1502             {
1503
1504                 try
1505                 {
1506                     ((ITextStyle)ws.Target).SetUnderlineType(type);
1507                 }
1508                 catch (Exception e)
1509                 {
1510                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1511                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1512                 }
1513
1514
1515             }
1516             else
1517             {
1518                 efl_text_underline_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
1519             }
1520         }
1521
1522         private static efl_text_underline_type_set_delegate efl_text_underline_type_set_static_delegate;
1523
1524
1525         private delegate void efl_text_underline_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
1526
1527
1528         public delegate void efl_text_underline_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
1529
1530         public static Efl.Eo.FunctionWrapper<efl_text_underline_color_get_api_delegate> efl_text_underline_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_color_get_api_delegate>(Module, "efl_text_underline_color_get");
1531
1532         private static void underline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
1533         {
1534             Eina.Log.Debug("function efl_text_underline_color_get was called");
1535             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1536             if (ws != null)
1537             {
1538                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
1539                 try
1540                 {
1541                     ((ITextStyle)ws.Target).GetUnderlineColor(out r, out g, out b, out a);
1542                 }
1543                 catch (Exception e)
1544                 {
1545                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1546                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1547                 }
1548
1549
1550             }
1551             else
1552             {
1553                 efl_text_underline_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1554             }
1555         }
1556
1557         private static efl_text_underline_color_get_delegate efl_text_underline_color_get_static_delegate;
1558
1559
1560         private delegate void efl_text_underline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
1561
1562
1563         public delegate void efl_text_underline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
1564
1565         public static Efl.Eo.FunctionWrapper<efl_text_underline_color_set_api_delegate> efl_text_underline_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_color_set_api_delegate>(Module, "efl_text_underline_color_set");
1566
1567         private static void underline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
1568         {
1569             Eina.Log.Debug("function efl_text_underline_color_set was called");
1570             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1571             if (ws != null)
1572             {
1573
1574                 try
1575                 {
1576                     ((ITextStyle)ws.Target).SetUnderlineColor(r, g, b, a);
1577                 }
1578                 catch (Exception e)
1579                 {
1580                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1581                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1582                 }
1583
1584
1585             }
1586             else
1587             {
1588                 efl_text_underline_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1589             }
1590         }
1591
1592         private static efl_text_underline_color_set_delegate efl_text_underline_color_set_static_delegate;
1593
1594
1595         private delegate double efl_text_underline_height_get_delegate(System.IntPtr obj, System.IntPtr pd);
1596
1597
1598         public delegate double efl_text_underline_height_get_api_delegate(System.IntPtr obj);
1599
1600         public static Efl.Eo.FunctionWrapper<efl_text_underline_height_get_api_delegate> efl_text_underline_height_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_height_get_api_delegate>(Module, "efl_text_underline_height_get");
1601
1602         private static double underline_height_get(System.IntPtr obj, System.IntPtr pd)
1603         {
1604             Eina.Log.Debug("function efl_text_underline_height_get was called");
1605             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1606             if (ws != null)
1607             {
1608             double _ret_var = default(double);
1609                 try
1610                 {
1611                     _ret_var = ((ITextStyle)ws.Target).GetUnderlineHeight();
1612                 }
1613                 catch (Exception e)
1614                 {
1615                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1616                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1617                 }
1618
1619         return _ret_var;
1620
1621             }
1622             else
1623             {
1624                 return efl_text_underline_height_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1625             }
1626         }
1627
1628         private static efl_text_underline_height_get_delegate efl_text_underline_height_get_static_delegate;
1629
1630
1631         private delegate void efl_text_underline_height_set_delegate(System.IntPtr obj, System.IntPtr pd,  double height);
1632
1633
1634         public delegate void efl_text_underline_height_set_api_delegate(System.IntPtr obj,  double height);
1635
1636         public static Efl.Eo.FunctionWrapper<efl_text_underline_height_set_api_delegate> efl_text_underline_height_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_height_set_api_delegate>(Module, "efl_text_underline_height_set");
1637
1638         private static void underline_height_set(System.IntPtr obj, System.IntPtr pd, double height)
1639         {
1640             Eina.Log.Debug("function efl_text_underline_height_set was called");
1641             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1642             if (ws != null)
1643             {
1644
1645                 try
1646                 {
1647                     ((ITextStyle)ws.Target).SetUnderlineHeight(height);
1648                 }
1649                 catch (Exception e)
1650                 {
1651                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1652                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1653                 }
1654
1655
1656             }
1657             else
1658             {
1659                 efl_text_underline_height_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), height);
1660             }
1661         }
1662
1663         private static efl_text_underline_height_set_delegate efl_text_underline_height_set_static_delegate;
1664
1665
1666         private delegate void efl_text_underline_dashed_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
1667
1668
1669         public delegate void efl_text_underline_dashed_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
1670
1671         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_color_get_api_delegate> efl_text_underline_dashed_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_color_get_api_delegate>(Module, "efl_text_underline_dashed_color_get");
1672
1673         private static void underline_dashed_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
1674         {
1675             Eina.Log.Debug("function efl_text_underline_dashed_color_get was called");
1676             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1677             if (ws != null)
1678             {
1679                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
1680                 try
1681                 {
1682                     ((ITextStyle)ws.Target).GetUnderlineDashedColor(out r, out g, out b, out a);
1683                 }
1684                 catch (Exception e)
1685                 {
1686                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1687                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1688                 }
1689
1690
1691             }
1692             else
1693             {
1694                 efl_text_underline_dashed_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1695             }
1696         }
1697
1698         private static efl_text_underline_dashed_color_get_delegate efl_text_underline_dashed_color_get_static_delegate;
1699
1700
1701         private delegate void efl_text_underline_dashed_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
1702
1703
1704         public delegate void efl_text_underline_dashed_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
1705
1706         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_color_set_api_delegate> efl_text_underline_dashed_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_color_set_api_delegate>(Module, "efl_text_underline_dashed_color_set");
1707
1708         private static void underline_dashed_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
1709         {
1710             Eina.Log.Debug("function efl_text_underline_dashed_color_set was called");
1711             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1712             if (ws != null)
1713             {
1714
1715                 try
1716                 {
1717                     ((ITextStyle)ws.Target).SetUnderlineDashedColor(r, g, b, a);
1718                 }
1719                 catch (Exception e)
1720                 {
1721                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1722                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1723                 }
1724
1725
1726             }
1727             else
1728             {
1729                 efl_text_underline_dashed_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1730             }
1731         }
1732
1733         private static efl_text_underline_dashed_color_set_delegate efl_text_underline_dashed_color_set_static_delegate;
1734
1735
1736         private delegate int efl_text_underline_dashed_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
1737
1738
1739         public delegate int efl_text_underline_dashed_width_get_api_delegate(System.IntPtr obj);
1740
1741         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_width_get_api_delegate> efl_text_underline_dashed_width_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_width_get_api_delegate>(Module, "efl_text_underline_dashed_width_get");
1742
1743         private static int underline_dashed_width_get(System.IntPtr obj, System.IntPtr pd)
1744         {
1745             Eina.Log.Debug("function efl_text_underline_dashed_width_get was called");
1746             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1747             if (ws != null)
1748             {
1749             int _ret_var = default(int);
1750                 try
1751                 {
1752                     _ret_var = ((ITextStyle)ws.Target).GetUnderlineDashedWidth();
1753                 }
1754                 catch (Exception e)
1755                 {
1756                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1757                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1758                 }
1759
1760         return _ret_var;
1761
1762             }
1763             else
1764             {
1765                 return efl_text_underline_dashed_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1766             }
1767         }
1768
1769         private static efl_text_underline_dashed_width_get_delegate efl_text_underline_dashed_width_get_static_delegate;
1770
1771
1772         private delegate void efl_text_underline_dashed_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  int width);
1773
1774
1775         public delegate void efl_text_underline_dashed_width_set_api_delegate(System.IntPtr obj,  int width);
1776
1777         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_width_set_api_delegate> efl_text_underline_dashed_width_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_width_set_api_delegate>(Module, "efl_text_underline_dashed_width_set");
1778
1779         private static void underline_dashed_width_set(System.IntPtr obj, System.IntPtr pd, int width)
1780         {
1781             Eina.Log.Debug("function efl_text_underline_dashed_width_set was called");
1782             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1783             if (ws != null)
1784             {
1785
1786                 try
1787                 {
1788                     ((ITextStyle)ws.Target).SetUnderlineDashedWidth(width);
1789                 }
1790                 catch (Exception e)
1791                 {
1792                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1793                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1794                 }
1795
1796
1797             }
1798             else
1799             {
1800                 efl_text_underline_dashed_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
1801             }
1802         }
1803
1804         private static efl_text_underline_dashed_width_set_delegate efl_text_underline_dashed_width_set_static_delegate;
1805
1806
1807         private delegate int efl_text_underline_dashed_gap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1808
1809
1810         public delegate int efl_text_underline_dashed_gap_get_api_delegate(System.IntPtr obj);
1811
1812         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_gap_get_api_delegate> efl_text_underline_dashed_gap_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_gap_get_api_delegate>(Module, "efl_text_underline_dashed_gap_get");
1813
1814         private static int underline_dashed_gap_get(System.IntPtr obj, System.IntPtr pd)
1815         {
1816             Eina.Log.Debug("function efl_text_underline_dashed_gap_get was called");
1817             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1818             if (ws != null)
1819             {
1820             int _ret_var = default(int);
1821                 try
1822                 {
1823                     _ret_var = ((ITextStyle)ws.Target).GetUnderlineDashedGap();
1824                 }
1825                 catch (Exception e)
1826                 {
1827                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1828                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1829                 }
1830
1831         return _ret_var;
1832
1833             }
1834             else
1835             {
1836                 return efl_text_underline_dashed_gap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1837             }
1838         }
1839
1840         private static efl_text_underline_dashed_gap_get_delegate efl_text_underline_dashed_gap_get_static_delegate;
1841
1842
1843         private delegate void efl_text_underline_dashed_gap_set_delegate(System.IntPtr obj, System.IntPtr pd,  int gap);
1844
1845
1846         public delegate void efl_text_underline_dashed_gap_set_api_delegate(System.IntPtr obj,  int gap);
1847
1848         public static Efl.Eo.FunctionWrapper<efl_text_underline_dashed_gap_set_api_delegate> efl_text_underline_dashed_gap_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline_dashed_gap_set_api_delegate>(Module, "efl_text_underline_dashed_gap_set");
1849
1850         private static void underline_dashed_gap_set(System.IntPtr obj, System.IntPtr pd, int gap)
1851         {
1852             Eina.Log.Debug("function efl_text_underline_dashed_gap_set was called");
1853             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1854             if (ws != null)
1855             {
1856
1857                 try
1858                 {
1859                     ((ITextStyle)ws.Target).SetUnderlineDashedGap(gap);
1860                 }
1861                 catch (Exception e)
1862                 {
1863                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1864                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1865                 }
1866
1867
1868             }
1869             else
1870             {
1871                 efl_text_underline_dashed_gap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gap);
1872             }
1873         }
1874
1875         private static efl_text_underline_dashed_gap_set_delegate efl_text_underline_dashed_gap_set_static_delegate;
1876
1877
1878         private delegate void efl_text_underline2_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
1879
1880
1881         public delegate void efl_text_underline2_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
1882
1883         public static Efl.Eo.FunctionWrapper<efl_text_underline2_color_get_api_delegate> efl_text_underline2_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline2_color_get_api_delegate>(Module, "efl_text_underline2_color_get");
1884
1885         private static void underline2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
1886         {
1887             Eina.Log.Debug("function efl_text_underline2_color_get was called");
1888             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1889             if (ws != null)
1890             {
1891                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
1892                 try
1893                 {
1894                     ((ITextStyle)ws.Target).GetUnderline2Color(out r, out g, out b, out a);
1895                 }
1896                 catch (Exception e)
1897                 {
1898                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1899                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1900                 }
1901
1902
1903             }
1904             else
1905             {
1906                 efl_text_underline2_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1907             }
1908         }
1909
1910         private static efl_text_underline2_color_get_delegate efl_text_underline2_color_get_static_delegate;
1911
1912
1913         private delegate void efl_text_underline2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
1914
1915
1916         public delegate void efl_text_underline2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
1917
1918         public static Efl.Eo.FunctionWrapper<efl_text_underline2_color_set_api_delegate> efl_text_underline2_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_underline2_color_set_api_delegate>(Module, "efl_text_underline2_color_set");
1919
1920         private static void underline2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
1921         {
1922             Eina.Log.Debug("function efl_text_underline2_color_set was called");
1923             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1924             if (ws != null)
1925             {
1926
1927                 try
1928                 {
1929                     ((ITextStyle)ws.Target).SetUnderline2Color(r, g, b, a);
1930                 }
1931                 catch (Exception e)
1932                 {
1933                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1934                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1935                 }
1936
1937
1938             }
1939             else
1940             {
1941                 efl_text_underline2_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1942             }
1943         }
1944
1945         private static efl_text_underline2_color_set_delegate efl_text_underline2_color_set_static_delegate;
1946
1947
1948         private delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1949
1950
1951         public delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_api_delegate(System.IntPtr obj);
1952
1953         public static Efl.Eo.FunctionWrapper<efl_text_strikethrough_type_get_api_delegate> efl_text_strikethrough_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_strikethrough_type_get_api_delegate>(Module, "efl_text_strikethrough_type_get");
1954
1955         private static Efl.TextStyleStrikethroughType strikethrough_type_get(System.IntPtr obj, System.IntPtr pd)
1956         {
1957             Eina.Log.Debug("function efl_text_strikethrough_type_get was called");
1958             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1959             if (ws != null)
1960             {
1961             Efl.TextStyleStrikethroughType _ret_var = default(Efl.TextStyleStrikethroughType);
1962                 try
1963                 {
1964                     _ret_var = ((ITextStyle)ws.Target).GetStrikethroughType();
1965                 }
1966                 catch (Exception e)
1967                 {
1968                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1969                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1970                 }
1971
1972         return _ret_var;
1973
1974             }
1975             else
1976             {
1977                 return efl_text_strikethrough_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1978             }
1979         }
1980
1981         private static efl_text_strikethrough_type_get_delegate efl_text_strikethrough_type_get_static_delegate;
1982
1983
1984         private delegate void efl_text_strikethrough_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleStrikethroughType type);
1985
1986
1987         public delegate void efl_text_strikethrough_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleStrikethroughType type);
1988
1989         public static Efl.Eo.FunctionWrapper<efl_text_strikethrough_type_set_api_delegate> efl_text_strikethrough_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_strikethrough_type_set_api_delegate>(Module, "efl_text_strikethrough_type_set");
1990
1991         private static void strikethrough_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleStrikethroughType type)
1992         {
1993             Eina.Log.Debug("function efl_text_strikethrough_type_set was called");
1994             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1995             if (ws != null)
1996             {
1997
1998                 try
1999                 {
2000                     ((ITextStyle)ws.Target).SetStrikethroughType(type);
2001                 }
2002                 catch (Exception e)
2003                 {
2004                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2005                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2006                 }
2007
2008
2009             }
2010             else
2011             {
2012                 efl_text_strikethrough_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
2013             }
2014         }
2015
2016         private static efl_text_strikethrough_type_set_delegate efl_text_strikethrough_type_set_static_delegate;
2017
2018
2019         private delegate void efl_text_strikethrough_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
2020
2021
2022         public delegate void efl_text_strikethrough_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
2023
2024         public static Efl.Eo.FunctionWrapper<efl_text_strikethrough_color_get_api_delegate> efl_text_strikethrough_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_strikethrough_color_get_api_delegate>(Module, "efl_text_strikethrough_color_get");
2025
2026         private static void strikethrough_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
2027         {
2028             Eina.Log.Debug("function efl_text_strikethrough_color_get was called");
2029             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2030             if (ws != null)
2031             {
2032                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
2033                 try
2034                 {
2035                     ((ITextStyle)ws.Target).GetStrikethroughColor(out r, out g, out b, out a);
2036                 }
2037                 catch (Exception e)
2038                 {
2039                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2040                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2041                 }
2042
2043
2044             }
2045             else
2046             {
2047                 efl_text_strikethrough_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
2048             }
2049         }
2050
2051         private static efl_text_strikethrough_color_get_delegate efl_text_strikethrough_color_get_static_delegate;
2052
2053
2054         private delegate void efl_text_strikethrough_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
2055
2056
2057         public delegate void efl_text_strikethrough_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
2058
2059         public static Efl.Eo.FunctionWrapper<efl_text_strikethrough_color_set_api_delegate> efl_text_strikethrough_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_strikethrough_color_set_api_delegate>(Module, "efl_text_strikethrough_color_set");
2060
2061         private static void strikethrough_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
2062         {
2063             Eina.Log.Debug("function efl_text_strikethrough_color_set was called");
2064             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2065             if (ws != null)
2066             {
2067
2068                 try
2069                 {
2070                     ((ITextStyle)ws.Target).SetStrikethroughColor(r, g, b, a);
2071                 }
2072                 catch (Exception e)
2073                 {
2074                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2075                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2076                 }
2077
2078
2079             }
2080             else
2081             {
2082                 efl_text_strikethrough_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
2083             }
2084         }
2085
2086         private static efl_text_strikethrough_color_set_delegate efl_text_strikethrough_color_set_static_delegate;
2087
2088
2089         private delegate Efl.TextStyleEffectType efl_text_effect_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
2090
2091
2092         public delegate Efl.TextStyleEffectType efl_text_effect_type_get_api_delegate(System.IntPtr obj);
2093
2094         public static Efl.Eo.FunctionWrapper<efl_text_effect_type_get_api_delegate> efl_text_effect_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_effect_type_get_api_delegate>(Module, "efl_text_effect_type_get");
2095
2096         private static Efl.TextStyleEffectType effect_type_get(System.IntPtr obj, System.IntPtr pd)
2097         {
2098             Eina.Log.Debug("function efl_text_effect_type_get was called");
2099             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2100             if (ws != null)
2101             {
2102             Efl.TextStyleEffectType _ret_var = default(Efl.TextStyleEffectType);
2103                 try
2104                 {
2105                     _ret_var = ((ITextStyle)ws.Target).GetEffectType();
2106                 }
2107                 catch (Exception e)
2108                 {
2109                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2110                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2111                 }
2112
2113         return _ret_var;
2114
2115             }
2116             else
2117             {
2118                 return efl_text_effect_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2119             }
2120         }
2121
2122         private static efl_text_effect_type_get_delegate efl_text_effect_type_get_static_delegate;
2123
2124
2125         private delegate void efl_text_effect_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleEffectType type);
2126
2127
2128         public delegate void efl_text_effect_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleEffectType type);
2129
2130         public static Efl.Eo.FunctionWrapper<efl_text_effect_type_set_api_delegate> efl_text_effect_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_effect_type_set_api_delegate>(Module, "efl_text_effect_type_set");
2131
2132         private static void effect_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleEffectType type)
2133         {
2134             Eina.Log.Debug("function efl_text_effect_type_set was called");
2135             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2136             if (ws != null)
2137             {
2138
2139                 try
2140                 {
2141                     ((ITextStyle)ws.Target).SetEffectType(type);
2142                 }
2143                 catch (Exception e)
2144                 {
2145                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2146                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2147                 }
2148
2149
2150             }
2151             else
2152             {
2153                 efl_text_effect_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
2154             }
2155         }
2156
2157         private static efl_text_effect_type_set_delegate efl_text_effect_type_set_static_delegate;
2158
2159
2160         private delegate void efl_text_outline_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
2161
2162
2163         public delegate void efl_text_outline_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
2164
2165         public static Efl.Eo.FunctionWrapper<efl_text_outline_color_get_api_delegate> efl_text_outline_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_outline_color_get_api_delegate>(Module, "efl_text_outline_color_get");
2166
2167         private static void outline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
2168         {
2169             Eina.Log.Debug("function efl_text_outline_color_get was called");
2170             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2171             if (ws != null)
2172             {
2173                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
2174                 try
2175                 {
2176                     ((ITextStyle)ws.Target).GetOutlineColor(out r, out g, out b, out a);
2177                 }
2178                 catch (Exception e)
2179                 {
2180                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2181                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2182                 }
2183
2184
2185             }
2186             else
2187             {
2188                 efl_text_outline_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
2189             }
2190         }
2191
2192         private static efl_text_outline_color_get_delegate efl_text_outline_color_get_static_delegate;
2193
2194
2195         private delegate void efl_text_outline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
2196
2197
2198         public delegate void efl_text_outline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
2199
2200         public static Efl.Eo.FunctionWrapper<efl_text_outline_color_set_api_delegate> efl_text_outline_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_outline_color_set_api_delegate>(Module, "efl_text_outline_color_set");
2201
2202         private static void outline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
2203         {
2204             Eina.Log.Debug("function efl_text_outline_color_set was called");
2205             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2206             if (ws != null)
2207             {
2208
2209                 try
2210                 {
2211                     ((ITextStyle)ws.Target).SetOutlineColor(r, g, b, a);
2212                 }
2213                 catch (Exception e)
2214                 {
2215                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2216                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2217                 }
2218
2219
2220             }
2221             else
2222             {
2223                 efl_text_outline_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
2224             }
2225         }
2226
2227         private static efl_text_outline_color_set_delegate efl_text_outline_color_set_static_delegate;
2228
2229
2230         private delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
2231
2232
2233         public delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_api_delegate(System.IntPtr obj);
2234
2235         public static Efl.Eo.FunctionWrapper<efl_text_shadow_direction_get_api_delegate> efl_text_shadow_direction_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_shadow_direction_get_api_delegate>(Module, "efl_text_shadow_direction_get");
2236
2237         private static Efl.TextStyleShadowDirection shadow_direction_get(System.IntPtr obj, System.IntPtr pd)
2238         {
2239             Eina.Log.Debug("function efl_text_shadow_direction_get was called");
2240             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2241             if (ws != null)
2242             {
2243             Efl.TextStyleShadowDirection _ret_var = default(Efl.TextStyleShadowDirection);
2244                 try
2245                 {
2246                     _ret_var = ((ITextStyle)ws.Target).GetShadowDirection();
2247                 }
2248                 catch (Exception e)
2249                 {
2250                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2251                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2252                 }
2253
2254         return _ret_var;
2255
2256             }
2257             else
2258             {
2259                 return efl_text_shadow_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2260             }
2261         }
2262
2263         private static efl_text_shadow_direction_get_delegate efl_text_shadow_direction_get_static_delegate;
2264
2265
2266         private delegate void efl_text_shadow_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleShadowDirection type);
2267
2268
2269         public delegate void efl_text_shadow_direction_set_api_delegate(System.IntPtr obj,  Efl.TextStyleShadowDirection type);
2270
2271         public static Efl.Eo.FunctionWrapper<efl_text_shadow_direction_set_api_delegate> efl_text_shadow_direction_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_shadow_direction_set_api_delegate>(Module, "efl_text_shadow_direction_set");
2272
2273         private static void shadow_direction_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleShadowDirection type)
2274         {
2275             Eina.Log.Debug("function efl_text_shadow_direction_set was called");
2276             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2277             if (ws != null)
2278             {
2279
2280                 try
2281                 {
2282                     ((ITextStyle)ws.Target).SetShadowDirection(type);
2283                 }
2284                 catch (Exception e)
2285                 {
2286                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2287                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2288                 }
2289
2290
2291             }
2292             else
2293             {
2294                 efl_text_shadow_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
2295             }
2296         }
2297
2298         private static efl_text_shadow_direction_set_delegate efl_text_shadow_direction_set_static_delegate;
2299
2300
2301         private delegate void efl_text_shadow_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
2302
2303
2304         public delegate void efl_text_shadow_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
2305
2306         public static Efl.Eo.FunctionWrapper<efl_text_shadow_color_get_api_delegate> efl_text_shadow_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_shadow_color_get_api_delegate>(Module, "efl_text_shadow_color_get");
2307
2308         private static void shadow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
2309         {
2310             Eina.Log.Debug("function efl_text_shadow_color_get was called");
2311             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2312             if (ws != null)
2313             {
2314                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
2315                 try
2316                 {
2317                     ((ITextStyle)ws.Target).GetShadowColor(out r, out g, out b, out a);
2318                 }
2319                 catch (Exception e)
2320                 {
2321                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2322                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2323                 }
2324
2325
2326             }
2327             else
2328             {
2329                 efl_text_shadow_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
2330             }
2331         }
2332
2333         private static efl_text_shadow_color_get_delegate efl_text_shadow_color_get_static_delegate;
2334
2335
2336         private delegate void efl_text_shadow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
2337
2338
2339         public delegate void efl_text_shadow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
2340
2341         public static Efl.Eo.FunctionWrapper<efl_text_shadow_color_set_api_delegate> efl_text_shadow_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_shadow_color_set_api_delegate>(Module, "efl_text_shadow_color_set");
2342
2343         private static void shadow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
2344         {
2345             Eina.Log.Debug("function efl_text_shadow_color_set was called");
2346             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2347             if (ws != null)
2348             {
2349
2350                 try
2351                 {
2352                     ((ITextStyle)ws.Target).SetShadowColor(r, g, b, a);
2353                 }
2354                 catch (Exception e)
2355                 {
2356                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2357                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2358                 }
2359
2360
2361             }
2362             else
2363             {
2364                 efl_text_shadow_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
2365             }
2366         }
2367
2368         private static efl_text_shadow_color_set_delegate efl_text_shadow_color_set_static_delegate;
2369
2370
2371         private delegate void efl_text_glow_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
2372
2373
2374         public delegate void efl_text_glow_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
2375
2376         public static Efl.Eo.FunctionWrapper<efl_text_glow_color_get_api_delegate> efl_text_glow_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_glow_color_get_api_delegate>(Module, "efl_text_glow_color_get");
2377
2378         private static void glow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
2379         {
2380             Eina.Log.Debug("function efl_text_glow_color_get was called");
2381             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2382             if (ws != null)
2383             {
2384                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
2385                 try
2386                 {
2387                     ((ITextStyle)ws.Target).GetGlowColor(out r, out g, out b, out a);
2388                 }
2389                 catch (Exception e)
2390                 {
2391                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2392                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2393                 }
2394
2395
2396             }
2397             else
2398             {
2399                 efl_text_glow_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
2400             }
2401         }
2402
2403         private static efl_text_glow_color_get_delegate efl_text_glow_color_get_static_delegate;
2404
2405
2406         private delegate void efl_text_glow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
2407
2408
2409         public delegate void efl_text_glow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
2410
2411         public static Efl.Eo.FunctionWrapper<efl_text_glow_color_set_api_delegate> efl_text_glow_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_glow_color_set_api_delegate>(Module, "efl_text_glow_color_set");
2412
2413         private static void glow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
2414         {
2415             Eina.Log.Debug("function efl_text_glow_color_set was called");
2416             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2417             if (ws != null)
2418             {
2419
2420                 try
2421                 {
2422                     ((ITextStyle)ws.Target).SetGlowColor(r, g, b, a);
2423                 }
2424                 catch (Exception e)
2425                 {
2426                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2427                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2428                 }
2429
2430
2431             }
2432             else
2433             {
2434                 efl_text_glow_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
2435             }
2436         }
2437
2438         private static efl_text_glow_color_set_delegate efl_text_glow_color_set_static_delegate;
2439
2440
2441         private delegate void efl_text_glow2_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out byte r,  out byte g,  out byte b,  out byte a);
2442
2443
2444         public delegate void efl_text_glow2_color_get_api_delegate(System.IntPtr obj,  out byte r,  out byte g,  out byte b,  out byte a);
2445
2446         public static Efl.Eo.FunctionWrapper<efl_text_glow2_color_get_api_delegate> efl_text_glow2_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_glow2_color_get_api_delegate>(Module, "efl_text_glow2_color_get");
2447
2448         private static void glow2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
2449         {
2450             Eina.Log.Debug("function efl_text_glow2_color_get was called");
2451             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2452             if (ws != null)
2453             {
2454                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
2455                 try
2456                 {
2457                     ((ITextStyle)ws.Target).GetGlow2Color(out r, out g, out b, out a);
2458                 }
2459                 catch (Exception e)
2460                 {
2461                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2462                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2463                 }
2464
2465
2466             }
2467             else
2468             {
2469                 efl_text_glow2_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
2470             }
2471         }
2472
2473         private static efl_text_glow2_color_get_delegate efl_text_glow2_color_get_static_delegate;
2474
2475
2476         private delegate void efl_text_glow2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
2477
2478
2479         public delegate void efl_text_glow2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
2480
2481         public static Efl.Eo.FunctionWrapper<efl_text_glow2_color_set_api_delegate> efl_text_glow2_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_glow2_color_set_api_delegate>(Module, "efl_text_glow2_color_set");
2482
2483         private static void glow2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
2484         {
2485             Eina.Log.Debug("function efl_text_glow2_color_set was called");
2486             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2487             if (ws != null)
2488             {
2489
2490                 try
2491                 {
2492                     ((ITextStyle)ws.Target).SetGlow2Color(r, g, b, a);
2493                 }
2494                 catch (Exception e)
2495                 {
2496                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2497                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2498                 }
2499
2500
2501             }
2502             else
2503             {
2504                 efl_text_glow2_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
2505             }
2506         }
2507
2508         private static efl_text_glow2_color_set_delegate efl_text_glow2_color_set_static_delegate;
2509
2510         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2511         private delegate System.String efl_text_gfx_filter_get_delegate(System.IntPtr obj, System.IntPtr pd);
2512
2513         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2514         public delegate System.String efl_text_gfx_filter_get_api_delegate(System.IntPtr obj);
2515
2516         public static Efl.Eo.FunctionWrapper<efl_text_gfx_filter_get_api_delegate> efl_text_gfx_filter_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_gfx_filter_get_api_delegate>(Module, "efl_text_gfx_filter_get");
2517
2518         private static System.String gfx_filter_get(System.IntPtr obj, System.IntPtr pd)
2519         {
2520             Eina.Log.Debug("function efl_text_gfx_filter_get was called");
2521             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2522             if (ws != null)
2523             {
2524             System.String _ret_var = default(System.String);
2525                 try
2526                 {
2527                     _ret_var = ((ITextStyle)ws.Target).GetGfxFilter();
2528                 }
2529                 catch (Exception e)
2530                 {
2531                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2532                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2533                 }
2534
2535         return _ret_var;
2536
2537             }
2538             else
2539             {
2540                 return efl_text_gfx_filter_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2541             }
2542         }
2543
2544         private static efl_text_gfx_filter_get_delegate efl_text_gfx_filter_get_static_delegate;
2545
2546
2547         private delegate void efl_text_gfx_filter_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code);
2548
2549
2550         public delegate void efl_text_gfx_filter_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code);
2551
2552         public static Efl.Eo.FunctionWrapper<efl_text_gfx_filter_set_api_delegate> efl_text_gfx_filter_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_gfx_filter_set_api_delegate>(Module, "efl_text_gfx_filter_set");
2553
2554         private static void gfx_filter_set(System.IntPtr obj, System.IntPtr pd, System.String code)
2555         {
2556             Eina.Log.Debug("function efl_text_gfx_filter_set was called");
2557             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2558             if (ws != null)
2559             {
2560
2561                 try
2562                 {
2563                     ((ITextStyle)ws.Target).SetGfxFilter(code);
2564                 }
2565                 catch (Exception e)
2566                 {
2567                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2568                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2569                 }
2570
2571
2572             }
2573             else
2574             {
2575                 efl_text_gfx_filter_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code);
2576             }
2577         }
2578
2579         private static efl_text_gfx_filter_set_delegate efl_text_gfx_filter_set_static_delegate;
2580
2581         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2582
2583 }
2584 }
2585 }
2586
2587 #if EFL_BETA
2588 #pragma warning disable CS1591
2589 public static class EflITextStyleConcrete_ExtensionMethods {
2590
2591     public static Efl.BindableProperty<Efl.TextStyleBackingType> BackingType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2592         return new Efl.BindableProperty<Efl.TextStyleBackingType>("backing_type", fac);
2593     }
2594
2595
2596     public static Efl.BindableProperty<Efl.TextStyleUnderlineType> UnderlineType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2597         return new Efl.BindableProperty<Efl.TextStyleUnderlineType>("underline_type", fac);
2598     }
2599
2600
2601     public static Efl.BindableProperty<double> UnderlineHeight<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2602         return new Efl.BindableProperty<double>("underline_height", fac);
2603     }
2604
2605
2606     public static Efl.BindableProperty<int> UnderlineDashedWidth<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2607         return new Efl.BindableProperty<int>("underline_dashed_width", fac);
2608     }
2609
2610     public static Efl.BindableProperty<int> UnderlineDashedGap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2611         return new Efl.BindableProperty<int>("underline_dashed_gap", fac);
2612     }
2613
2614
2615     public static Efl.BindableProperty<Efl.TextStyleStrikethroughType> StrikethroughType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2616         return new Efl.BindableProperty<Efl.TextStyleStrikethroughType>("strikethrough_type", fac);
2617     }
2618
2619
2620     public static Efl.BindableProperty<Efl.TextStyleEffectType> EffectType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2621         return new Efl.BindableProperty<Efl.TextStyleEffectType>("effect_type", fac);
2622     }
2623
2624
2625     public static Efl.BindableProperty<Efl.TextStyleShadowDirection> ShadowDirection<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2626         return new Efl.BindableProperty<Efl.TextStyleShadowDirection>("shadow_direction", fac);
2627     }
2628
2629
2630
2631
2632     public static Efl.BindableProperty<System.String> GfxFilter<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextStyle, T>magic = null) where T : Efl.ITextStyle {
2633         return new Efl.BindableProperty<System.String>("gfx_filter", fac);
2634     }
2635
2636 }
2637 #pragma warning restore CS1591
2638 #endif
2639 namespace Efl {
2640
2641 /// <summary>Whether to apply backing style to the displayed text or not</summary>
2642 [Efl.Eo.BindingEntity]
2643 public enum TextStyleBackingType
2644 {
2645 /// <summary>Do not use backing</summary>
2646 Disabled = 0,
2647 /// <summary>Use backing style</summary>
2648 Enabled = 1,
2649 }
2650
2651 }
2652
2653 namespace Efl {
2654
2655 /// <summary>Whether to apply strikethrough style to the displayed text or not</summary>
2656 [Efl.Eo.BindingEntity]
2657 public enum TextStyleStrikethroughType
2658 {
2659 /// <summary>Do not use strikethrough</summary>
2660 Disabled = 0,
2661 /// <summary>Use strikethrough style</summary>
2662 Enabled = 1,
2663 }
2664
2665 }
2666
2667 namespace Efl {
2668
2669 /// <summary>Effect to apply to the displayed text</summary>
2670 [Efl.Eo.BindingEntity]
2671 public enum TextStyleEffectType
2672 {
2673 /// <summary>No effect</summary>
2674 None = 0,
2675 /// <summary>Shadow effect</summary>
2676 Shadow = 1,
2677 /// <summary>Far shadow effect</summary>
2678 FarShadow = 2,
2679 /// <summary>Soft shadow effect</summary>
2680 SoftShadow = 3,
2681 /// <summary>Far and soft shadow effect</summary>
2682 FarSoftShadow = 4,
2683 /// <summary>Glow effect</summary>
2684 Glow = 5,
2685 /// <summary>Outline effect</summary>
2686 Outline = 6,
2687 /// <summary>Soft outline effect</summary>
2688 SoftOutline = 7,
2689 /// <summary>Outline shadow effect</summary>
2690 OutlineShadow = 8,
2691 /// <summary>Outline soft shadow effect</summary>
2692 OutlineSoftShadow = 9,
2693 }
2694
2695 }
2696
2697 namespace Efl {
2698
2699 /// <summary>Direction of the shadow style, if used</summary>
2700 [Efl.Eo.BindingEntity]
2701 public enum TextStyleShadowDirection
2702 {
2703 /// <summary>Shadow towards bottom right</summary>
2704 BottomRight = 0,
2705 /// <summary>Shadow towards botom</summary>
2706 Bottom = 1,
2707 /// <summary>Shadow towards bottom left</summary>
2708 BottomLeft = 2,
2709 /// <summary>Shadow towards left</summary>
2710 Left = 3,
2711 /// <summary>Shadow towards top left</summary>
2712 TopLeft = 4,
2713 /// <summary>Shadow towards top</summary>
2714 Top = 5,
2715 /// <summary>Shadow towards top right</summary>
2716 TopRight = 6,
2717 /// <summary>Shadow towards right</summary>
2718 Right = 7,
2719 }
2720
2721 }
2722
2723 namespace Efl {
2724
2725 /// <summary>Underline type of the displayed text</summary>
2726 [Efl.Eo.BindingEntity]
2727 public enum TextStyleUnderlineType
2728 {
2729 /// <summary>Text without underline</summary>
2730 Off = 0,
2731 /// <summary>Underline enabled</summary>
2732 On = 1,
2733 /// <summary>Underlined with a signle line</summary>
2734 Single = 2,
2735 /// <summary>Underlined with a double line</summary>
2736 Double = 3,
2737 /// <summary>Underlined with a dashed line</summary>
2738 Dashed = 4,
2739 }
2740
2741 }
2742