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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 /// <summary>The look and layout of the text
  12 /// The text format can affect the geometry of the text object, as well as how characters are presented.</summary>
  13 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  14 [Efl.ITextFormatConcrete.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public interface ITextFormat :
  17     Efl.Eo.IWrapper, IDisposable
  18 {
  19     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
  20 /// <returns>Ellipsis value</returns>
  21 double GetEllipsis();
  22     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
  23 /// <param name="value">Ellipsis value</param>
  24 void SetEllipsis(double value);
  25     /// <summary>Wrap mode for use in the text</summary>
  26 /// <returns>Wrap mode</returns>
  27 Efl.TextFormatWrap GetWrap();
  28     /// <summary>Wrap mode for use in the text</summary>
  29 /// <param name="wrap">Wrap mode</param>
  30 void SetWrap(Efl.TextFormatWrap wrap);
  31     /// <summary>Multiline is enabled or not</summary>
  32 /// <returns><c>true</c> if multiline is enabled, <c>false</c> otherwise</returns>
  33 bool GetMultiline();
  34     /// <summary>Multiline is enabled or not</summary>
  35 /// <param name="enabled"><c>true</c> if multiline is enabled, <c>false</c> otherwise</param>
  36 void SetMultiline(bool enabled);
  37     /// <summary>Horizontal alignment of text</summary>
  38 /// <returns>Alignment type</returns>
  39 Efl.TextFormatHorizontalAlignmentAutoType GetHalignAutoType();
  40     /// <summary>Horizontal alignment of text</summary>
  41 /// <param name="value">Alignment type</param>
  42 void SetHalignAutoType(Efl.TextFormatHorizontalAlignmentAutoType value);
  43     /// <summary>Horizontal alignment of text</summary>
  44 /// <returns>Horizontal alignment value</returns>
  45 double GetHalign();
  46     /// <summary>Horizontal alignment of text</summary>
  47 /// <param name="value">Horizontal alignment value</param>
  48 void SetHalign(double value);
  49     /// <summary>Vertical alignment of text</summary>
  50 /// <returns>Vertical alignment value</returns>
  51 double GetValign();
  52     /// <summary>Vertical alignment of text</summary>
  53 /// <param name="value">Vertical alignment value</param>
  54 void SetValign(double value);
  55     /// <summary>Minimal line gap (top and bottom) for each line in the text
  56 /// <c>value</c> is absolute size.</summary>
  57 /// <returns>Line gap value</returns>
  58 double GetLinegap();
  59     /// <summary>Minimal line gap (top and bottom) for each line in the text
  60 /// <c>value</c> is absolute size.</summary>
  61 /// <param name="value">Line gap value</param>
  62 void SetLinegap(double value);
  63     /// <summary>Relative line gap (top and bottom) for each line in the text
  64 /// The original line gap value is multiplied by <c>value</c>.</summary>
  65 /// <returns>Relative line gap value</returns>
  66 double GetLinerelgap();
  67     /// <summary>Relative line gap (top and bottom) for each line in the text
  68 /// The original line gap value is multiplied by <c>value</c>.</summary>
  69 /// <param name="value">Relative line gap value</param>
  70 void SetLinerelgap(double value);
  71     /// <summary>Tabstops value</summary>
  72 /// <returns>Tapstops value</returns>
  73 int GetTabstops();
  74     /// <summary>Tabstops value</summary>
  75 /// <param name="value">Tapstops value</param>
  76 void SetTabstops(int value);
  77     /// <summary>Whether text is a password</summary>
  78 /// <returns><c>true</c> if the text is a password, <c>false</c> otherwise</returns>
  79 bool GetPassword();
  80     /// <summary>Whether text is a password</summary>
  81 /// <param name="enabled"><c>true</c> if the text is a password, <c>false</c> otherwise</param>
  82 void SetPassword(bool enabled);
  83     /// <summary>The character used to replace characters that can&apos;t be displayed
  84 /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
  85 /// <returns>Replacement character</returns>
  86 System.String GetReplacementChar();
  87     /// <summary>The character used to replace characters that can&apos;t be displayed
  88 /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
  89 /// <param name="repch">Replacement character</param>
  90 void SetReplacementChar(System.String repch);
  91                                                                                             /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
  92     /// <value>Ellipsis value</value>
  93     double Ellipsis {
  94         get;
  95         set;
  96     }
  97     /// <summary>Wrap mode for use in the text</summary>
  98     /// <value>Wrap mode</value>
  99     Efl.TextFormatWrap Wrap {
 100         get;
 101         set;
 102     }
 103     /// <summary>Multiline is enabled or not</summary>
 104     /// <value><c>true</c> if multiline is enabled, <c>false</c> otherwise</value>
 105     bool Multiline {
 106         get;
 107         set;
 108     }
 109     /// <summary>Horizontal alignment of text</summary>
 110     /// <value>Alignment type</value>
 111     Efl.TextFormatHorizontalAlignmentAutoType HalignAutoType {
 112         get;
 113         set;
 114     }
 115     /// <summary>Horizontal alignment of text</summary>
 116     /// <value>Horizontal alignment value</value>
 117     double Halign {
 118         get;
 119         set;
 120     }
 121     /// <summary>Vertical alignment of text</summary>
 122     /// <value>Vertical alignment value</value>
 123     double Valign {
 124         get;
 125         set;
 126     }
 127     /// <summary>Minimal line gap (top and bottom) for each line in the text
 128     /// <c>value</c> is absolute size.</summary>
 129     /// <value>Line gap value</value>
 130     double Linegap {
 131         get;
 132         set;
 133     }
 134     /// <summary>Relative line gap (top and bottom) for each line in the text
 135     /// The original line gap value is multiplied by <c>value</c>.</summary>
 136     /// <value>Relative line gap value</value>
 137     double Linerelgap {
 138         get;
 139         set;
 140     }
 141     /// <summary>Tabstops value</summary>
 142     /// <value>Tapstops value</value>
 143     int Tabstops {
 144         get;
 145         set;
 146     }
 147     /// <summary>Whether text is a password</summary>
 148     /// <value><c>true</c> if the text is a password, <c>false</c> otherwise</value>
 149     bool Password {
 150         get;
 151         set;
 152     }
 153     /// <summary>The character used to replace characters that can&apos;t be displayed
 154     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 155     /// <value>Replacement character</value>
 156     System.String ReplacementChar {
 157         get;
 158         set;
 159     }
 160 }
 161 /// <summary>The look and layout of the text
 162 /// The text format can affect the geometry of the text object, as well as how characters are presented.</summary>
 163 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
 164 sealed public  class ITextFormatConcrete :
 165     Efl.Eo.EoWrapper
 166     , ITextFormat
 167
 168 {
 169     /// <summary>Pointer to the native class description.</summary>
 170     public override System.IntPtr NativeClass
 171     {
 172         get
 173         {
 174             if (((object)this).GetType() == typeof(ITextFormatConcrete))
 175             {
 176                 return GetEflClassStatic();
 177             }
 178             else
 179             {
 180                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 181             }
 182         }
 183     }
 184
 185     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
 186     /// Do not call this constructor directly.</summary>
 187     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 188     private ITextFormatConcrete(ConstructingHandle ch) : base(ch)
 189     {
 190     }
 191
 192     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 193         efl_text_format_interface_get();
 194     /// <summary>Initializes a new instance of the <see cref="ITextFormat"/> class.
 195     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 196     /// <param name="wh">The native pointer to be wrapped.</param>
 197     private ITextFormatConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 198     {
 199     }
 200
 201     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 202     /// <returns>Ellipsis value</returns>
 203     public double GetEllipsis() {
 204          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_get_ptr.Value.Delegate(this.NativeHandle);
 205         Eina.Error.RaiseIfUnhandledException();
 206         return _ret_var;
 207  }
 208     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 209     /// <param name="value">Ellipsis value</param>
 210     public void SetEllipsis(double value) {
 211                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_set_ptr.Value.Delegate(this.NativeHandle,value);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <summary>Wrap mode for use in the text</summary>
 215     /// <returns>Wrap mode</returns>
 216     public Efl.TextFormatWrap GetWrap() {
 217          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_get_ptr.Value.Delegate(this.NativeHandle);
 218         Eina.Error.RaiseIfUnhandledException();
 219         return _ret_var;
 220  }
 221     /// <summary>Wrap mode for use in the text</summary>
 222     /// <param name="wrap">Wrap mode</param>
 223     public void SetWrap(Efl.TextFormatWrap wrap) {
 224                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_set_ptr.Value.Delegate(this.NativeHandle,wrap);
 225         Eina.Error.RaiseIfUnhandledException();
 226                          }
 227     /// <summary>Multiline is enabled or not</summary>
 228     /// <returns><c>true</c> if multiline is enabled, <c>false</c> otherwise</returns>
 229     public bool GetMultiline() {
 230          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_get_ptr.Value.Delegate(this.NativeHandle);
 231         Eina.Error.RaiseIfUnhandledException();
 232         return _ret_var;
 233  }
 234     /// <summary>Multiline is enabled or not</summary>
 235     /// <param name="enabled"><c>true</c> if multiline is enabled, <c>false</c> otherwise</param>
 236     public void SetMultiline(bool enabled) {
 237                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_set_ptr.Value.Delegate(this.NativeHandle,enabled);
 238         Eina.Error.RaiseIfUnhandledException();
 239                          }
 240     /// <summary>Horizontal alignment of text</summary>
 241     /// <returns>Alignment type</returns>
 242     public Efl.TextFormatHorizontalAlignmentAutoType GetHalignAutoType() {
 243          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_get_ptr.Value.Delegate(this.NativeHandle);
 244         Eina.Error.RaiseIfUnhandledException();
 245         return _ret_var;
 246  }
 247     /// <summary>Horizontal alignment of text</summary>
 248     /// <param name="value">Alignment type</param>
 249     public void SetHalignAutoType(Efl.TextFormatHorizontalAlignmentAutoType value) {
 250                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_set_ptr.Value.Delegate(this.NativeHandle,value);
 251         Eina.Error.RaiseIfUnhandledException();
 252                          }
 253     /// <summary>Horizontal alignment of text</summary>
 254     /// <returns>Horizontal alignment value</returns>
 255     public double GetHalign() {
 256          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_get_ptr.Value.Delegate(this.NativeHandle);
 257         Eina.Error.RaiseIfUnhandledException();
 258         return _ret_var;
 259  }
 260     /// <summary>Horizontal alignment of text</summary>
 261     /// <param name="value">Horizontal alignment value</param>
 262     public void SetHalign(double value) {
 263                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_set_ptr.Value.Delegate(this.NativeHandle,value);
 264         Eina.Error.RaiseIfUnhandledException();
 265                          }
 266     /// <summary>Vertical alignment of text</summary>
 267     /// <returns>Vertical alignment value</returns>
 268     public double GetValign() {
 269          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_get_ptr.Value.Delegate(this.NativeHandle);
 270         Eina.Error.RaiseIfUnhandledException();
 271         return _ret_var;
 272  }
 273     /// <summary>Vertical alignment of text</summary>
 274     /// <param name="value">Vertical alignment value</param>
 275     public void SetValign(double value) {
 276                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_set_ptr.Value.Delegate(this.NativeHandle,value);
 277         Eina.Error.RaiseIfUnhandledException();
 278                          }
 279     /// <summary>Minimal line gap (top and bottom) for each line in the text
 280     /// <c>value</c> is absolute size.</summary>
 281     /// <returns>Line gap value</returns>
 282     public double GetLinegap() {
 283          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_get_ptr.Value.Delegate(this.NativeHandle);
 284         Eina.Error.RaiseIfUnhandledException();
 285         return _ret_var;
 286  }
 287     /// <summary>Minimal line gap (top and bottom) for each line in the text
 288     /// <c>value</c> is absolute size.</summary>
 289     /// <param name="value">Line gap value</param>
 290     public void SetLinegap(double value) {
 291                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_set_ptr.Value.Delegate(this.NativeHandle,value);
 292         Eina.Error.RaiseIfUnhandledException();
 293                          }
 294     /// <summary>Relative line gap (top and bottom) for each line in the text
 295     /// The original line gap value is multiplied by <c>value</c>.</summary>
 296     /// <returns>Relative line gap value</returns>
 297     public double GetLinerelgap() {
 298          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_get_ptr.Value.Delegate(this.NativeHandle);
 299         Eina.Error.RaiseIfUnhandledException();
 300         return _ret_var;
 301  }
 302     /// <summary>Relative line gap (top and bottom) for each line in the text
 303     /// The original line gap value is multiplied by <c>value</c>.</summary>
 304     /// <param name="value">Relative line gap value</param>
 305     public void SetLinerelgap(double value) {
 306                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_set_ptr.Value.Delegate(this.NativeHandle,value);
 307         Eina.Error.RaiseIfUnhandledException();
 308                          }
 309     /// <summary>Tabstops value</summary>
 310     /// <returns>Tapstops value</returns>
 311     public int GetTabstops() {
 312          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_get_ptr.Value.Delegate(this.NativeHandle);
 313         Eina.Error.RaiseIfUnhandledException();
 314         return _ret_var;
 315  }
 316     /// <summary>Tabstops value</summary>
 317     /// <param name="value">Tapstops value</param>
 318     public void SetTabstops(int value) {
 319                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_set_ptr.Value.Delegate(this.NativeHandle,value);
 320         Eina.Error.RaiseIfUnhandledException();
 321                          }
 322     /// <summary>Whether text is a password</summary>
 323     /// <returns><c>true</c> if the text is a password, <c>false</c> otherwise</returns>
 324     public bool GetPassword() {
 325          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_password_get_ptr.Value.Delegate(this.NativeHandle);
 326         Eina.Error.RaiseIfUnhandledException();
 327         return _ret_var;
 328  }
 329     /// <summary>Whether text is a password</summary>
 330     /// <param name="enabled"><c>true</c> if the text is a password, <c>false</c> otherwise</param>
 331     public void SetPassword(bool enabled) {
 332                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_password_set_ptr.Value.Delegate(this.NativeHandle,enabled);
 333         Eina.Error.RaiseIfUnhandledException();
 334                          }
 335     /// <summary>The character used to replace characters that can&apos;t be displayed
 336     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 337     /// <returns>Replacement character</returns>
 338     public System.String GetReplacementChar() {
 339          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_get_ptr.Value.Delegate(this.NativeHandle);
 340         Eina.Error.RaiseIfUnhandledException();
 341         return _ret_var;
 342  }
 343     /// <summary>The character used to replace characters that can&apos;t be displayed
 344     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 345     /// <param name="repch">Replacement character</param>
 346     public void SetReplacementChar(System.String repch) {
 347                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_set_ptr.Value.Delegate(this.NativeHandle,repch);
 348         Eina.Error.RaiseIfUnhandledException();
 349                          }
 350     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 351     /// <value>Ellipsis value</value>
 352     public double Ellipsis {
 353         get { return GetEllipsis(); }
 354         set { SetEllipsis(value); }
 355     }
 356     /// <summary>Wrap mode for use in the text</summary>
 357     /// <value>Wrap mode</value>
 358     public Efl.TextFormatWrap Wrap {
 359         get { return GetWrap(); }
 360         set { SetWrap(value); }
 361     }
 362     /// <summary>Multiline is enabled or not</summary>
 363     /// <value><c>true</c> if multiline is enabled, <c>false</c> otherwise</value>
 364     public bool Multiline {
 365         get { return GetMultiline(); }
 366         set { SetMultiline(value); }
 367     }
 368     /// <summary>Horizontal alignment of text</summary>
 369     /// <value>Alignment type</value>
 370     public Efl.TextFormatHorizontalAlignmentAutoType HalignAutoType {
 371         get { return GetHalignAutoType(); }
 372         set { SetHalignAutoType(value); }
 373     }
 374     /// <summary>Horizontal alignment of text</summary>
 375     /// <value>Horizontal alignment value</value>
 376     public double Halign {
 377         get { return GetHalign(); }
 378         set { SetHalign(value); }
 379     }
 380     /// <summary>Vertical alignment of text</summary>
 381     /// <value>Vertical alignment value</value>
 382     public double Valign {
 383         get { return GetValign(); }
 384         set { SetValign(value); }
 385     }
 386     /// <summary>Minimal line gap (top and bottom) for each line in the text
 387     /// <c>value</c> is absolute size.</summary>
 388     /// <value>Line gap value</value>
 389     public double Linegap {
 390         get { return GetLinegap(); }
 391         set { SetLinegap(value); }
 392     }
 393     /// <summary>Relative line gap (top and bottom) for each line in the text
 394     /// The original line gap value is multiplied by <c>value</c>.</summary>
 395     /// <value>Relative line gap value</value>
 396     public double Linerelgap {
 397         get { return GetLinerelgap(); }
 398         set { SetLinerelgap(value); }
 399     }
 400     /// <summary>Tabstops value</summary>
 401     /// <value>Tapstops value</value>
 402     public int Tabstops {
 403         get { return GetTabstops(); }
 404         set { SetTabstops(value); }
 405     }
 406     /// <summary>Whether text is a password</summary>
 407     /// <value><c>true</c> if the text is a password, <c>false</c> otherwise</value>
 408     public bool Password {
 409         get { return GetPassword(); }
 410         set { SetPassword(value); }
 411     }
 412     /// <summary>The character used to replace characters that can&apos;t be displayed
 413     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 414     /// <value>Replacement character</value>
 415     public System.String ReplacementChar {
 416         get { return GetReplacementChar(); }
 417         set { SetReplacementChar(value); }
 418     }
 419     private static IntPtr GetEflClassStatic()
 420     {
 421         return Efl.ITextFormatConcrete.efl_text_format_interface_get();
 422     }
 423     /// <summary>Wrapper for native methods and virtual method delegates.
 424     /// For internal use by generated code only.</summary>
 425     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 426     {
 427         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 428         /// <summary>Gets the list of Eo operations to override.</summary>
 429         /// <returns>The list of Eo operations to be overload.</returns>
 430         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 431         {
 432             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 433             var methods = Efl.Eo.Globals.GetUserMethods(type);
 434
 435             if (efl_text_ellipsis_get_static_delegate == null)
 436             {
 437                 efl_text_ellipsis_get_static_delegate = new efl_text_ellipsis_get_delegate(ellipsis_get);
 438             }
 439
 440             if (methods.FirstOrDefault(m => m.Name == "GetEllipsis") != null)
 441             {
 442                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_ellipsis_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_ellipsis_get_static_delegate) });
 443             }
 444
 445             if (efl_text_ellipsis_set_static_delegate == null)
 446             {
 447                 efl_text_ellipsis_set_static_delegate = new efl_text_ellipsis_set_delegate(ellipsis_set);
 448             }
 449
 450             if (methods.FirstOrDefault(m => m.Name == "SetEllipsis") != null)
 451             {
 452                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_ellipsis_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_ellipsis_set_static_delegate) });
 453             }
 454
 455             if (efl_text_wrap_get_static_delegate == null)
 456             {
 457                 efl_text_wrap_get_static_delegate = new efl_text_wrap_get_delegate(wrap_get);
 458             }
 459
 460             if (methods.FirstOrDefault(m => m.Name == "GetWrap") != null)
 461             {
 462                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_wrap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_wrap_get_static_delegate) });
 463             }
 464
 465             if (efl_text_wrap_set_static_delegate == null)
 466             {
 467                 efl_text_wrap_set_static_delegate = new efl_text_wrap_set_delegate(wrap_set);
 468             }
 469
 470             if (methods.FirstOrDefault(m => m.Name == "SetWrap") != null)
 471             {
 472                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_wrap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_wrap_set_static_delegate) });
 473             }
 474
 475             if (efl_text_multiline_get_static_delegate == null)
 476             {
 477                 efl_text_multiline_get_static_delegate = new efl_text_multiline_get_delegate(multiline_get);
 478             }
 479
 480             if (methods.FirstOrDefault(m => m.Name == "GetMultiline") != null)
 481             {
 482                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_multiline_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_multiline_get_static_delegate) });
 483             }
 484
 485             if (efl_text_multiline_set_static_delegate == null)
 486             {
 487                 efl_text_multiline_set_static_delegate = new efl_text_multiline_set_delegate(multiline_set);
 488             }
 489
 490             if (methods.FirstOrDefault(m => m.Name == "SetMultiline") != null)
 491             {
 492                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_multiline_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_multiline_set_static_delegate) });
 493             }
 494
 495             if (efl_text_halign_auto_type_get_static_delegate == null)
 496             {
 497                 efl_text_halign_auto_type_get_static_delegate = new efl_text_halign_auto_type_get_delegate(halign_auto_type_get);
 498             }
 499
 500             if (methods.FirstOrDefault(m => m.Name == "GetHalignAutoType") != null)
 501             {
 502                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_halign_auto_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_halign_auto_type_get_static_delegate) });
 503             }
 504
 505             if (efl_text_halign_auto_type_set_static_delegate == null)
 506             {
 507                 efl_text_halign_auto_type_set_static_delegate = new efl_text_halign_auto_type_set_delegate(halign_auto_type_set);
 508             }
 509
 510             if (methods.FirstOrDefault(m => m.Name == "SetHalignAutoType") != null)
 511             {
 512                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_halign_auto_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_halign_auto_type_set_static_delegate) });
 513             }
 514
 515             if (efl_text_halign_get_static_delegate == null)
 516             {
 517                 efl_text_halign_get_static_delegate = new efl_text_halign_get_delegate(halign_get);
 518             }
 519
 520             if (methods.FirstOrDefault(m => m.Name == "GetHalign") != null)
 521             {
 522                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_halign_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_halign_get_static_delegate) });
 523             }
 524
 525             if (efl_text_halign_set_static_delegate == null)
 526             {
 527                 efl_text_halign_set_static_delegate = new efl_text_halign_set_delegate(halign_set);
 528             }
 529
 530             if (methods.FirstOrDefault(m => m.Name == "SetHalign") != null)
 531             {
 532                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_halign_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_halign_set_static_delegate) });
 533             }
 534
 535             if (efl_text_valign_get_static_delegate == null)
 536             {
 537                 efl_text_valign_get_static_delegate = new efl_text_valign_get_delegate(valign_get);
 538             }
 539
 540             if (methods.FirstOrDefault(m => m.Name == "GetValign") != null)
 541             {
 542                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_valign_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_valign_get_static_delegate) });
 543             }
 544
 545             if (efl_text_valign_set_static_delegate == null)
 546             {
 547                 efl_text_valign_set_static_delegate = new efl_text_valign_set_delegate(valign_set);
 548             }
 549
 550             if (methods.FirstOrDefault(m => m.Name == "SetValign") != null)
 551             {
 552                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_valign_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_valign_set_static_delegate) });
 553             }
 554
 555             if (efl_text_linegap_get_static_delegate == null)
 556             {
 557                 efl_text_linegap_get_static_delegate = new efl_text_linegap_get_delegate(linegap_get);
 558             }
 559
 560             if (methods.FirstOrDefault(m => m.Name == "GetLinegap") != null)
 561             {
 562                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_linegap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_linegap_get_static_delegate) });
 563             }
 564
 565             if (efl_text_linegap_set_static_delegate == null)
 566             {
 567                 efl_text_linegap_set_static_delegate = new efl_text_linegap_set_delegate(linegap_set);
 568             }
 569
 570             if (methods.FirstOrDefault(m => m.Name == "SetLinegap") != null)
 571             {
 572                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_linegap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_linegap_set_static_delegate) });
 573             }
 574
 575             if (efl_text_linerelgap_get_static_delegate == null)
 576             {
 577                 efl_text_linerelgap_get_static_delegate = new efl_text_linerelgap_get_delegate(linerelgap_get);
 578             }
 579
 580             if (methods.FirstOrDefault(m => m.Name == "GetLinerelgap") != null)
 581             {
 582                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_linerelgap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_linerelgap_get_static_delegate) });
 583             }
 584
 585             if (efl_text_linerelgap_set_static_delegate == null)
 586             {
 587                 efl_text_linerelgap_set_static_delegate = new efl_text_linerelgap_set_delegate(linerelgap_set);
 588             }
 589
 590             if (methods.FirstOrDefault(m => m.Name == "SetLinerelgap") != null)
 591             {
 592                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_linerelgap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_linerelgap_set_static_delegate) });
 593             }
 594
 595             if (efl_text_tabstops_get_static_delegate == null)
 596             {
 597                 efl_text_tabstops_get_static_delegate = new efl_text_tabstops_get_delegate(tabstops_get);
 598             }
 599
 600             if (methods.FirstOrDefault(m => m.Name == "GetTabstops") != null)
 601             {
 602                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_tabstops_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_tabstops_get_static_delegate) });
 603             }
 604
 605             if (efl_text_tabstops_set_static_delegate == null)
 606             {
 607                 efl_text_tabstops_set_static_delegate = new efl_text_tabstops_set_delegate(tabstops_set);
 608             }
 609
 610             if (methods.FirstOrDefault(m => m.Name == "SetTabstops") != null)
 611             {
 612                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_tabstops_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_tabstops_set_static_delegate) });
 613             }
 614
 615             if (efl_text_password_get_static_delegate == null)
 616             {
 617                 efl_text_password_get_static_delegate = new efl_text_password_get_delegate(password_get);
 618             }
 619
 620             if (methods.FirstOrDefault(m => m.Name == "GetPassword") != null)
 621             {
 622                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_password_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_password_get_static_delegate) });
 623             }
 624
 625             if (efl_text_password_set_static_delegate == null)
 626             {
 627                 efl_text_password_set_static_delegate = new efl_text_password_set_delegate(password_set);
 628             }
 629
 630             if (methods.FirstOrDefault(m => m.Name == "SetPassword") != null)
 631             {
 632                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_password_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_password_set_static_delegate) });
 633             }
 634
 635             if (efl_text_replacement_char_get_static_delegate == null)
 636             {
 637                 efl_text_replacement_char_get_static_delegate = new efl_text_replacement_char_get_delegate(replacement_char_get);
 638             }
 639
 640             if (methods.FirstOrDefault(m => m.Name == "GetReplacementChar") != null)
 641             {
 642                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_replacement_char_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_replacement_char_get_static_delegate) });
 643             }
 644
 645             if (efl_text_replacement_char_set_static_delegate == null)
 646             {
 647                 efl_text_replacement_char_set_static_delegate = new efl_text_replacement_char_set_delegate(replacement_char_set);
 648             }
 649
 650             if (methods.FirstOrDefault(m => m.Name == "SetReplacementChar") != null)
 651             {
 652                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_replacement_char_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_replacement_char_set_static_delegate) });
 653             }
 654
 655             return descs;
 656         }
 657         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 658         /// <returns>The native class pointer.</returns>
 659         public override IntPtr GetEflClass()
 660         {
 661             return Efl.ITextFormatConcrete.efl_text_format_interface_get();
 662         }
 663
 664         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 665
 666
 667         private delegate double efl_text_ellipsis_get_delegate(System.IntPtr obj, System.IntPtr pd);
 668
 669
 670         public delegate double efl_text_ellipsis_get_api_delegate(System.IntPtr obj);
 671
 672         public static Efl.Eo.FunctionWrapper<efl_text_ellipsis_get_api_delegate> efl_text_ellipsis_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_ellipsis_get_api_delegate>(Module, "efl_text_ellipsis_get");
 673
 674         private static double ellipsis_get(System.IntPtr obj, System.IntPtr pd)
 675         {
 676             Eina.Log.Debug("function efl_text_ellipsis_get was called");
 677             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 678             if (ws != null)
 679             {
 680             double _ret_var = default(double);
 681                 try
 682                 {
 683                     _ret_var = ((ITextFormat)ws.Target).GetEllipsis();
 684                 }
 685                 catch (Exception e)
 686                 {
 687                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 688                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 689                 }
 690
 691         return _ret_var;
 692
 693             }
 694             else
 695             {
 696                 return efl_text_ellipsis_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 697             }
 698         }
 699
 700         private static efl_text_ellipsis_get_delegate efl_text_ellipsis_get_static_delegate;
 701
 702
 703         private delegate void efl_text_ellipsis_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
 704
 705
 706         public delegate void efl_text_ellipsis_set_api_delegate(System.IntPtr obj,  double value);
 707
 708         public static Efl.Eo.FunctionWrapper<efl_text_ellipsis_set_api_delegate> efl_text_ellipsis_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_ellipsis_set_api_delegate>(Module, "efl_text_ellipsis_set");
 709
 710         private static void ellipsis_set(System.IntPtr obj, System.IntPtr pd, double value)
 711         {
 712             Eina.Log.Debug("function efl_text_ellipsis_set was called");
 713             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 714             if (ws != null)
 715             {
 716
 717                 try
 718                 {
 719                     ((ITextFormat)ws.Target).SetEllipsis(value);
 720                 }
 721                 catch (Exception e)
 722                 {
 723                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 724                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 725                 }
 726
 727
 728             }
 729             else
 730             {
 731                 efl_text_ellipsis_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
 732             }
 733         }
 734
 735         private static efl_text_ellipsis_set_delegate efl_text_ellipsis_set_static_delegate;
 736
 737
 738         private delegate Efl.TextFormatWrap efl_text_wrap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 739
 740
 741         public delegate Efl.TextFormatWrap efl_text_wrap_get_api_delegate(System.IntPtr obj);
 742
 743         public static Efl.Eo.FunctionWrapper<efl_text_wrap_get_api_delegate> efl_text_wrap_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_wrap_get_api_delegate>(Module, "efl_text_wrap_get");
 744
 745         private static Efl.TextFormatWrap wrap_get(System.IntPtr obj, System.IntPtr pd)
 746         {
 747             Eina.Log.Debug("function efl_text_wrap_get was called");
 748             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 749             if (ws != null)
 750             {
 751             Efl.TextFormatWrap _ret_var = default(Efl.TextFormatWrap);
 752                 try
 753                 {
 754                     _ret_var = ((ITextFormat)ws.Target).GetWrap();
 755                 }
 756                 catch (Exception e)
 757                 {
 758                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 759                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 760                 }
 761
 762         return _ret_var;
 763
 764             }
 765             else
 766             {
 767                 return efl_text_wrap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 768             }
 769         }
 770
 771         private static efl_text_wrap_get_delegate efl_text_wrap_get_static_delegate;
 772
 773
 774         private delegate void efl_text_wrap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatWrap wrap);
 775
 776
 777         public delegate void efl_text_wrap_set_api_delegate(System.IntPtr obj,  Efl.TextFormatWrap wrap);
 778
 779         public static Efl.Eo.FunctionWrapper<efl_text_wrap_set_api_delegate> efl_text_wrap_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_wrap_set_api_delegate>(Module, "efl_text_wrap_set");
 780
 781         private static void wrap_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatWrap wrap)
 782         {
 783             Eina.Log.Debug("function efl_text_wrap_set was called");
 784             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 785             if (ws != null)
 786             {
 787
 788                 try
 789                 {
 790                     ((ITextFormat)ws.Target).SetWrap(wrap);
 791                 }
 792                 catch (Exception e)
 793                 {
 794                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 795                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 796                 }
 797
 798
 799             }
 800             else
 801             {
 802                 efl_text_wrap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), wrap);
 803             }
 804         }
 805
 806         private static efl_text_wrap_set_delegate efl_text_wrap_set_static_delegate;
 807
 808         [return: MarshalAs(UnmanagedType.U1)]
 809         private delegate bool efl_text_multiline_get_delegate(System.IntPtr obj, System.IntPtr pd);
 810
 811         [return: MarshalAs(UnmanagedType.U1)]
 812         public delegate bool efl_text_multiline_get_api_delegate(System.IntPtr obj);
 813
 814         public static Efl.Eo.FunctionWrapper<efl_text_multiline_get_api_delegate> efl_text_multiline_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_multiline_get_api_delegate>(Module, "efl_text_multiline_get");
 815
 816         private static bool multiline_get(System.IntPtr obj, System.IntPtr pd)
 817         {
 818             Eina.Log.Debug("function efl_text_multiline_get was called");
 819             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 820             if (ws != null)
 821             {
 822             bool _ret_var = default(bool);
 823                 try
 824                 {
 825                     _ret_var = ((ITextFormat)ws.Target).GetMultiline();
 826                 }
 827                 catch (Exception e)
 828                 {
 829                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 830                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 831                 }
 832
 833         return _ret_var;
 834
 835             }
 836             else
 837             {
 838                 return efl_text_multiline_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 839             }
 840         }
 841
 842         private static efl_text_multiline_get_delegate efl_text_multiline_get_static_delegate;
 843
 844
 845         private delegate void efl_text_multiline_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
 846
 847
 848         public delegate void efl_text_multiline_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
 849
 850         public static Efl.Eo.FunctionWrapper<efl_text_multiline_set_api_delegate> efl_text_multiline_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_multiline_set_api_delegate>(Module, "efl_text_multiline_set");
 851
 852         private static void multiline_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
 853         {
 854             Eina.Log.Debug("function efl_text_multiline_set was called");
 855             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 856             if (ws != null)
 857             {
 858
 859                 try
 860                 {
 861                     ((ITextFormat)ws.Target).SetMultiline(enabled);
 862                 }
 863                 catch (Exception e)
 864                 {
 865                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 866                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 867                 }
 868
 869
 870             }
 871             else
 872             {
 873                 efl_text_multiline_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
 874             }
 875         }
 876
 877         private static efl_text_multiline_set_delegate efl_text_multiline_set_static_delegate;
 878
 879
 880         private delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 881
 882
 883         public delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_api_delegate(System.IntPtr obj);
 884
 885         public static Efl.Eo.FunctionWrapper<efl_text_halign_auto_type_get_api_delegate> efl_text_halign_auto_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_halign_auto_type_get_api_delegate>(Module, "efl_text_halign_auto_type_get");
 886
 887         private static Efl.TextFormatHorizontalAlignmentAutoType halign_auto_type_get(System.IntPtr obj, System.IntPtr pd)
 888         {
 889             Eina.Log.Debug("function efl_text_halign_auto_type_get was called");
 890             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 891             if (ws != null)
 892             {
 893             Efl.TextFormatHorizontalAlignmentAutoType _ret_var = default(Efl.TextFormatHorizontalAlignmentAutoType);
 894                 try
 895                 {
 896                     _ret_var = ((ITextFormat)ws.Target).GetHalignAutoType();
 897                 }
 898                 catch (Exception e)
 899                 {
 900                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 901                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 902                 }
 903
 904         return _ret_var;
 905
 906             }
 907             else
 908             {
 909                 return efl_text_halign_auto_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 910             }
 911         }
 912
 913         private static efl_text_halign_auto_type_get_delegate efl_text_halign_auto_type_get_static_delegate;
 914
 915
 916         private delegate void efl_text_halign_auto_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatHorizontalAlignmentAutoType value);
 917
 918
 919         public delegate void efl_text_halign_auto_type_set_api_delegate(System.IntPtr obj,  Efl.TextFormatHorizontalAlignmentAutoType value);
 920
 921         public static Efl.Eo.FunctionWrapper<efl_text_halign_auto_type_set_api_delegate> efl_text_halign_auto_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_halign_auto_type_set_api_delegate>(Module, "efl_text_halign_auto_type_set");
 922
 923         private static void halign_auto_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatHorizontalAlignmentAutoType value)
 924         {
 925             Eina.Log.Debug("function efl_text_halign_auto_type_set was called");
 926             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 927             if (ws != null)
 928             {
 929
 930                 try
 931                 {
 932                     ((ITextFormat)ws.Target).SetHalignAutoType(value);
 933                 }
 934                 catch (Exception e)
 935                 {
 936                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 937                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 938                 }
 939
 940
 941             }
 942             else
 943             {
 944                 efl_text_halign_auto_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
 945             }
 946         }
 947
 948         private static efl_text_halign_auto_type_set_delegate efl_text_halign_auto_type_set_static_delegate;
 949
 950
 951         private delegate double efl_text_halign_get_delegate(System.IntPtr obj, System.IntPtr pd);
 952
 953
 954         public delegate double efl_text_halign_get_api_delegate(System.IntPtr obj);
 955
 956         public static Efl.Eo.FunctionWrapper<efl_text_halign_get_api_delegate> efl_text_halign_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_halign_get_api_delegate>(Module, "efl_text_halign_get");
 957
 958         private static double halign_get(System.IntPtr obj, System.IntPtr pd)
 959         {
 960             Eina.Log.Debug("function efl_text_halign_get was called");
 961             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 962             if (ws != null)
 963             {
 964             double _ret_var = default(double);
 965                 try
 966                 {
 967                     _ret_var = ((ITextFormat)ws.Target).GetHalign();
 968                 }
 969                 catch (Exception e)
 970                 {
 971                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 972                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 973                 }
 974
 975         return _ret_var;
 976
 977             }
 978             else
 979             {
 980                 return efl_text_halign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 981             }
 982         }
 983
 984         private static efl_text_halign_get_delegate efl_text_halign_get_static_delegate;
 985
 986
 987         private delegate void efl_text_halign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
 988
 989
 990         public delegate void efl_text_halign_set_api_delegate(System.IntPtr obj,  double value);
 991
 992         public static Efl.Eo.FunctionWrapper<efl_text_halign_set_api_delegate> efl_text_halign_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_halign_set_api_delegate>(Module, "efl_text_halign_set");
 993
 994         private static void halign_set(System.IntPtr obj, System.IntPtr pd, double value)
 995         {
 996             Eina.Log.Debug("function efl_text_halign_set was called");
 997             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 998             if (ws != null)
 999             {
1000
1001                 try
1002                 {
1003                     ((ITextFormat)ws.Target).SetHalign(value);
1004                 }
1005                 catch (Exception e)
1006                 {
1007                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1008                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1009                 }
1010
1011
1012             }
1013             else
1014             {
1015                 efl_text_halign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
1016             }
1017         }
1018
1019         private static efl_text_halign_set_delegate efl_text_halign_set_static_delegate;
1020
1021
1022         private delegate double efl_text_valign_get_delegate(System.IntPtr obj, System.IntPtr pd);
1023
1024
1025         public delegate double efl_text_valign_get_api_delegate(System.IntPtr obj);
1026
1027         public static Efl.Eo.FunctionWrapper<efl_text_valign_get_api_delegate> efl_text_valign_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_valign_get_api_delegate>(Module, "efl_text_valign_get");
1028
1029         private static double valign_get(System.IntPtr obj, System.IntPtr pd)
1030         {
1031             Eina.Log.Debug("function efl_text_valign_get was called");
1032             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1033             if (ws != null)
1034             {
1035             double _ret_var = default(double);
1036                 try
1037                 {
1038                     _ret_var = ((ITextFormat)ws.Target).GetValign();
1039                 }
1040                 catch (Exception e)
1041                 {
1042                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1043                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1044                 }
1045
1046         return _ret_var;
1047
1048             }
1049             else
1050             {
1051                 return efl_text_valign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1052             }
1053         }
1054
1055         private static efl_text_valign_get_delegate efl_text_valign_get_static_delegate;
1056
1057
1058         private delegate void efl_text_valign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
1059
1060
1061         public delegate void efl_text_valign_set_api_delegate(System.IntPtr obj,  double value);
1062
1063         public static Efl.Eo.FunctionWrapper<efl_text_valign_set_api_delegate> efl_text_valign_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_valign_set_api_delegate>(Module, "efl_text_valign_set");
1064
1065         private static void valign_set(System.IntPtr obj, System.IntPtr pd, double value)
1066         {
1067             Eina.Log.Debug("function efl_text_valign_set was called");
1068             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1069             if (ws != null)
1070             {
1071
1072                 try
1073                 {
1074                     ((ITextFormat)ws.Target).SetValign(value);
1075                 }
1076                 catch (Exception e)
1077                 {
1078                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1079                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1080                 }
1081
1082
1083             }
1084             else
1085             {
1086                 efl_text_valign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
1087             }
1088         }
1089
1090         private static efl_text_valign_set_delegate efl_text_valign_set_static_delegate;
1091
1092
1093         private delegate double efl_text_linegap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1094
1095
1096         public delegate double efl_text_linegap_get_api_delegate(System.IntPtr obj);
1097
1098         public static Efl.Eo.FunctionWrapper<efl_text_linegap_get_api_delegate> efl_text_linegap_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_linegap_get_api_delegate>(Module, "efl_text_linegap_get");
1099
1100         private static double linegap_get(System.IntPtr obj, System.IntPtr pd)
1101         {
1102             Eina.Log.Debug("function efl_text_linegap_get was called");
1103             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1104             if (ws != null)
1105             {
1106             double _ret_var = default(double);
1107                 try
1108                 {
1109                     _ret_var = ((ITextFormat)ws.Target).GetLinegap();
1110                 }
1111                 catch (Exception e)
1112                 {
1113                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1114                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1115                 }
1116
1117         return _ret_var;
1118
1119             }
1120             else
1121             {
1122                 return efl_text_linegap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1123             }
1124         }
1125
1126         private static efl_text_linegap_get_delegate efl_text_linegap_get_static_delegate;
1127
1128
1129         private delegate void efl_text_linegap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
1130
1131
1132         public delegate void efl_text_linegap_set_api_delegate(System.IntPtr obj,  double value);
1133
1134         public static Efl.Eo.FunctionWrapper<efl_text_linegap_set_api_delegate> efl_text_linegap_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_linegap_set_api_delegate>(Module, "efl_text_linegap_set");
1135
1136         private static void linegap_set(System.IntPtr obj, System.IntPtr pd, double value)
1137         {
1138             Eina.Log.Debug("function efl_text_linegap_set was called");
1139             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1140             if (ws != null)
1141             {
1142
1143                 try
1144                 {
1145                     ((ITextFormat)ws.Target).SetLinegap(value);
1146                 }
1147                 catch (Exception e)
1148                 {
1149                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1150                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1151                 }
1152
1153
1154             }
1155             else
1156             {
1157                 efl_text_linegap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
1158             }
1159         }
1160
1161         private static efl_text_linegap_set_delegate efl_text_linegap_set_static_delegate;
1162
1163
1164         private delegate double efl_text_linerelgap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1165
1166
1167         public delegate double efl_text_linerelgap_get_api_delegate(System.IntPtr obj);
1168
1169         public static Efl.Eo.FunctionWrapper<efl_text_linerelgap_get_api_delegate> efl_text_linerelgap_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_linerelgap_get_api_delegate>(Module, "efl_text_linerelgap_get");
1170
1171         private static double linerelgap_get(System.IntPtr obj, System.IntPtr pd)
1172         {
1173             Eina.Log.Debug("function efl_text_linerelgap_get was called");
1174             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1175             if (ws != null)
1176             {
1177             double _ret_var = default(double);
1178                 try
1179                 {
1180                     _ret_var = ((ITextFormat)ws.Target).GetLinerelgap();
1181                 }
1182                 catch (Exception e)
1183                 {
1184                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1185                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1186                 }
1187
1188         return _ret_var;
1189
1190             }
1191             else
1192             {
1193                 return efl_text_linerelgap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1194             }
1195         }
1196
1197         private static efl_text_linerelgap_get_delegate efl_text_linerelgap_get_static_delegate;
1198
1199
1200         private delegate void efl_text_linerelgap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
1201
1202
1203         public delegate void efl_text_linerelgap_set_api_delegate(System.IntPtr obj,  double value);
1204
1205         public static Efl.Eo.FunctionWrapper<efl_text_linerelgap_set_api_delegate> efl_text_linerelgap_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_linerelgap_set_api_delegate>(Module, "efl_text_linerelgap_set");
1206
1207         private static void linerelgap_set(System.IntPtr obj, System.IntPtr pd, double value)
1208         {
1209             Eina.Log.Debug("function efl_text_linerelgap_set was called");
1210             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1211             if (ws != null)
1212             {
1213
1214                 try
1215                 {
1216                     ((ITextFormat)ws.Target).SetLinerelgap(value);
1217                 }
1218                 catch (Exception e)
1219                 {
1220                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1221                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1222                 }
1223
1224
1225             }
1226             else
1227             {
1228                 efl_text_linerelgap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
1229             }
1230         }
1231
1232         private static efl_text_linerelgap_set_delegate efl_text_linerelgap_set_static_delegate;
1233
1234
1235         private delegate int efl_text_tabstops_get_delegate(System.IntPtr obj, System.IntPtr pd);
1236
1237
1238         public delegate int efl_text_tabstops_get_api_delegate(System.IntPtr obj);
1239
1240         public static Efl.Eo.FunctionWrapper<efl_text_tabstops_get_api_delegate> efl_text_tabstops_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_tabstops_get_api_delegate>(Module, "efl_text_tabstops_get");
1241
1242         private static int tabstops_get(System.IntPtr obj, System.IntPtr pd)
1243         {
1244             Eina.Log.Debug("function efl_text_tabstops_get was called");
1245             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1246             if (ws != null)
1247             {
1248             int _ret_var = default(int);
1249                 try
1250                 {
1251                     _ret_var = ((ITextFormat)ws.Target).GetTabstops();
1252                 }
1253                 catch (Exception e)
1254                 {
1255                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1256                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1257                 }
1258
1259         return _ret_var;
1260
1261             }
1262             else
1263             {
1264                 return efl_text_tabstops_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1265             }
1266         }
1267
1268         private static efl_text_tabstops_get_delegate efl_text_tabstops_get_static_delegate;
1269
1270
1271         private delegate void efl_text_tabstops_set_delegate(System.IntPtr obj, System.IntPtr pd,  int value);
1272
1273
1274         public delegate void efl_text_tabstops_set_api_delegate(System.IntPtr obj,  int value);
1275
1276         public static Efl.Eo.FunctionWrapper<efl_text_tabstops_set_api_delegate> efl_text_tabstops_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_tabstops_set_api_delegate>(Module, "efl_text_tabstops_set");
1277
1278         private static void tabstops_set(System.IntPtr obj, System.IntPtr pd, int value)
1279         {
1280             Eina.Log.Debug("function efl_text_tabstops_set was called");
1281             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1282             if (ws != null)
1283             {
1284
1285                 try
1286                 {
1287                     ((ITextFormat)ws.Target).SetTabstops(value);
1288                 }
1289                 catch (Exception e)
1290                 {
1291                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1292                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1293                 }
1294
1295
1296             }
1297             else
1298             {
1299                 efl_text_tabstops_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
1300             }
1301         }
1302
1303         private static efl_text_tabstops_set_delegate efl_text_tabstops_set_static_delegate;
1304
1305         [return: MarshalAs(UnmanagedType.U1)]
1306         private delegate bool efl_text_password_get_delegate(System.IntPtr obj, System.IntPtr pd);
1307
1308         [return: MarshalAs(UnmanagedType.U1)]
1309         public delegate bool efl_text_password_get_api_delegate(System.IntPtr obj);
1310
1311         public static Efl.Eo.FunctionWrapper<efl_text_password_get_api_delegate> efl_text_password_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_password_get_api_delegate>(Module, "efl_text_password_get");
1312
1313         private static bool password_get(System.IntPtr obj, System.IntPtr pd)
1314         {
1315             Eina.Log.Debug("function efl_text_password_get was called");
1316             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1317             if (ws != null)
1318             {
1319             bool _ret_var = default(bool);
1320                 try
1321                 {
1322                     _ret_var = ((ITextFormat)ws.Target).GetPassword();
1323                 }
1324                 catch (Exception e)
1325                 {
1326                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1327                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1328                 }
1329
1330         return _ret_var;
1331
1332             }
1333             else
1334             {
1335                 return efl_text_password_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1336             }
1337         }
1338
1339         private static efl_text_password_get_delegate efl_text_password_get_static_delegate;
1340
1341
1342         private delegate void efl_text_password_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
1343
1344
1345         public delegate void efl_text_password_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
1346
1347         public static Efl.Eo.FunctionWrapper<efl_text_password_set_api_delegate> efl_text_password_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_password_set_api_delegate>(Module, "efl_text_password_set");
1348
1349         private static void password_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
1350         {
1351             Eina.Log.Debug("function efl_text_password_set was called");
1352             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1353             if (ws != null)
1354             {
1355
1356                 try
1357                 {
1358                     ((ITextFormat)ws.Target).SetPassword(enabled);
1359                 }
1360                 catch (Exception e)
1361                 {
1362                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1363                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1364                 }
1365
1366
1367             }
1368             else
1369             {
1370                 efl_text_password_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
1371             }
1372         }
1373
1374         private static efl_text_password_set_delegate efl_text_password_set_static_delegate;
1375
1376         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1377         private delegate System.String efl_text_replacement_char_get_delegate(System.IntPtr obj, System.IntPtr pd);
1378
1379         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1380         public delegate System.String efl_text_replacement_char_get_api_delegate(System.IntPtr obj);
1381
1382         public static Efl.Eo.FunctionWrapper<efl_text_replacement_char_get_api_delegate> efl_text_replacement_char_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_replacement_char_get_api_delegate>(Module, "efl_text_replacement_char_get");
1383
1384         private static System.String replacement_char_get(System.IntPtr obj, System.IntPtr pd)
1385         {
1386             Eina.Log.Debug("function efl_text_replacement_char_get was called");
1387             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1388             if (ws != null)
1389             {
1390             System.String _ret_var = default(System.String);
1391                 try
1392                 {
1393                     _ret_var = ((ITextFormat)ws.Target).GetReplacementChar();
1394                 }
1395                 catch (Exception e)
1396                 {
1397                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1398                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1399                 }
1400
1401         return _ret_var;
1402
1403             }
1404             else
1405             {
1406                 return efl_text_replacement_char_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1407             }
1408         }
1409
1410         private static efl_text_replacement_char_get_delegate efl_text_replacement_char_get_static_delegate;
1411
1412
1413         private delegate void efl_text_replacement_char_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String repch);
1414
1415
1416         public delegate void efl_text_replacement_char_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String repch);
1417
1418         public static Efl.Eo.FunctionWrapper<efl_text_replacement_char_set_api_delegate> efl_text_replacement_char_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_replacement_char_set_api_delegate>(Module, "efl_text_replacement_char_set");
1419
1420         private static void replacement_char_set(System.IntPtr obj, System.IntPtr pd, System.String repch)
1421         {
1422             Eina.Log.Debug("function efl_text_replacement_char_set was called");
1423             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1424             if (ws != null)
1425             {
1426
1427                 try
1428                 {
1429                     ((ITextFormat)ws.Target).SetReplacementChar(repch);
1430                 }
1431                 catch (Exception e)
1432                 {
1433                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1434                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1435                 }
1436
1437
1438             }
1439             else
1440             {
1441                 efl_text_replacement_char_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), repch);
1442             }
1443         }
1444
1445         private static efl_text_replacement_char_set_delegate efl_text_replacement_char_set_static_delegate;
1446
1447         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1448
1449 }
1450 }
1451 }
1452
1453 #if EFL_BETA
1454 #pragma warning disable CS1591
1455 public static class EflITextFormatConcrete_ExtensionMethods {
1456     public static Efl.BindableProperty<double> Ellipsis<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1457         return new Efl.BindableProperty<double>("ellipsis", fac);
1458     }
1459
1460     public static Efl.BindableProperty<Efl.TextFormatWrap> Wrap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1461         return new Efl.BindableProperty<Efl.TextFormatWrap>("wrap", fac);
1462     }
1463
1464     public static Efl.BindableProperty<bool> Multiline<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1465         return new Efl.BindableProperty<bool>("multiline", fac);
1466     }
1467
1468     public static Efl.BindableProperty<Efl.TextFormatHorizontalAlignmentAutoType> HalignAutoType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1469         return new Efl.BindableProperty<Efl.TextFormatHorizontalAlignmentAutoType>("halign_auto_type", fac);
1470     }
1471
1472     public static Efl.BindableProperty<double> Halign<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1473         return new Efl.BindableProperty<double>("halign", fac);
1474     }
1475
1476     public static Efl.BindableProperty<double> Valign<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1477         return new Efl.BindableProperty<double>("valign", fac);
1478     }
1479
1480     public static Efl.BindableProperty<double> Linegap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1481         return new Efl.BindableProperty<double>("linegap", fac);
1482     }
1483
1484     public static Efl.BindableProperty<double> Linerelgap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1485         return new Efl.BindableProperty<double>("linerelgap", fac);
1486     }
1487
1488     public static Efl.BindableProperty<int> Tabstops<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1489         return new Efl.BindableProperty<int>("tabstops", fac);
1490     }
1491
1492     public static Efl.BindableProperty<bool> Password<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1493         return new Efl.BindableProperty<bool>("password", fac);
1494     }
1495
1496     public static Efl.BindableProperty<System.String> ReplacementChar<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextFormat, T>magic = null) where T : Efl.ITextFormat {
1497         return new Efl.BindableProperty<System.String>("replacement_char", fac);
1498     }
1499
1500 }
1501 #pragma warning restore CS1591
1502 #endif
1503 namespace Efl {
1504
1505 /// <summary>Wrap mode of the text (not in effect if not multiline)</summary>
1506 [Efl.Eo.BindingEntity]
1507 public enum TextFormatWrap
1508 {
1509 /// <summary>No wrapping</summary>
1510 None = 0,
1511 /// <summary>Wrap mode character</summary>
1512 Char = 1,
1513 /// <summary>Wrap mode word</summary>
1514 Word = 2,
1515 /// <summary>Wrap mode mixed</summary>
1516 Mixed = 3,
1517 /// <summary>Wrap mode hyphenation</summary>
1518 Hyphenation = 4,
1519 }
1520
1521 }
1522
1523 namespace Efl {
1524
1525 /// <summary>Auto-horizontal alignment of the text</summary>
1526 [Efl.Eo.BindingEntity]
1527 public enum TextFormatHorizontalAlignmentAutoType
1528 {
1529 /// <summary>No auto-alignment rule</summary>
1530 None = 0,
1531 /// <summary>Respects LTR/RTL (bidirectional) settings</summary>
1532 Normal = 1,
1533 /// <summary>Respects locale&apos;s langauge settings</summary>
1534 Locale = 2,
1535 /// <summary>Text is places at opposite side of LTR/RTL (bidirectional) settings</summary>
1536 End = 3,
1537 }
1538
1539 }
1540