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