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

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