internals/src/EflSharp/EflSharp/efl/efl_text_interactive.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>This is an interface interactive text inputs should implement</summary>
  12 /// <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>
  13 [Efl.ITextInteractiveConcrete.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public interface ITextInteractive :
  16     Efl.IText ,
  17     Efl.ITextFont ,
  18     Efl.ITextFormat ,
  19     Efl.ITextStyle ,
  20     Efl.Eo.IWrapper, IDisposable
  21 {
  22     /// <summary>Whether or not selection is allowed on this object</summary>
  23 /// <returns><c>true</c> if enabled, <c>false</c> otherwise</returns>
  24 bool GetSelectionAllowed();
  25     /// <summary>Whether or not selection is allowed on this object</summary>
  26 /// <param name="allowed"><c>true</c> if enabled, <c>false</c> otherwise</param>
  27 void SetSelectionAllowed(bool allowed);
  28     /// <summary>The cursors used for selection handling.
  29 /// If the cursors are equal there&apos;s no selection.
  30 ///
  31 /// You are allowed to retain and modify them. Modifying them modifies the selection of the object.</summary>
  32 /// <param name="start">The start of the selection</param>
  33 /// <param name="end">The end of the selection</param>
  34 void GetSelectionCursors(out Efl.TextCursorCursor start, out Efl.TextCursorCursor end);
  35     /// <summary>Whether the entry is editable.
  36 /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
  37 /// <returns>If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</returns>
  38 bool GetEditable();
  39     /// <summary>Whether the entry is editable.
  40 /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
  41 /// <param name="editable">If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</param>
  42 void SetEditable(bool editable);
  43     /// <summary>Clears the selection.</summary>
  44 void SelectNone();
  45                             /// <summary>The selection on the object has changed. Query using <see cref="Efl.ITextInteractive.GetSelectionCursors"/></summary>
  46     event EventHandler TextSelectionChangedEvt;
  47     /// <summary>Whether or not selection is allowed on this object</summary>
  48     /// <value><c>true</c> if enabled, <c>false</c> otherwise</value>
  49     bool SelectionAllowed {
  50         get;
  51         set;
  52     }
  53     /// <summary>The cursors used for selection handling.
  54     /// If the cursors are equal there&apos;s no selection.
  55     ///
  56     /// You are allowed to retain and modify them. Modifying them modifies the selection of the object.</summary>
  57     (Efl.TextCursorCursor, Efl.TextCursorCursor) SelectionCursors {
  58         get;
  59     }
  60     /// <summary>Whether the entry is editable.
  61     /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
  62     /// <value>If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</value>
  63     bool Editable {
  64         get;
  65         set;
  66     }
  67 }
  68 /// <summary>This is an interface interactive text inputs should implement</summary>
  69 /// <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>
  70 sealed public  class ITextInteractiveConcrete :
  71     Efl.Eo.EoWrapper
  72     , ITextInteractive
  73     , Efl.IText, Efl.ITextFont, Efl.ITextFormat, Efl.ITextStyle
  74 {
  75     /// <summary>Pointer to the native class description.</summary>
  76     public override System.IntPtr NativeClass
  77     {
  78         get
  79         {
  80             if (((object)this).GetType() == typeof(ITextInteractiveConcrete))
  81             {
  82                 return GetEflClassStatic();
  83             }
  84             else
  85             {
  86                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  87             }
  88         }
  89     }
  90
  91     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  92     /// Do not call this constructor directly.</summary>
  93     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  94     private ITextInteractiveConcrete(ConstructingHandle ch) : base(ch)
  95     {
  96     }
  97
  98     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  99         efl_text_interactive_interface_get();
 100     /// <summary>Initializes a new instance of the <see cref="ITextInteractive"/> class.
 101     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 102     /// <param name="wh">The native pointer to be wrapped.</param>
 103     private ITextInteractiveConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 104     {
 105     }
 106
 107     /// <summary>The selection on the object has changed. Query using <see cref="Efl.ITextInteractive.GetSelectionCursors"/></summary>
 108     public event EventHandler TextSelectionChangedEvt
 109     {
 110         add
 111         {
 112             lock (eflBindingEventLock)
 113             {
 114                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 115                 {
 116                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 117                     if (obj != null)
 118                     {
 119                         EventArgs args = EventArgs.Empty;
 120                         try
 121                         {
 122                             value?.Invoke(obj, args);
 123                         }
 124                         catch (Exception e)
 125                         {
 126                             Eina.Log.Error(e.ToString());
 127                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 128                         }
 129                     }
 130                 };
 131
 132                 string key = "_EFL_TEXT_INTERACTIVE_EVENT_TEXT_SELECTION_CHANGED";
 133                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 134             }
 135         }
 136
 137         remove
 138         {
 139             lock (eflBindingEventLock)
 140             {
 141                 string key = "_EFL_TEXT_INTERACTIVE_EVENT_TEXT_SELECTION_CHANGED";
 142                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 143             }
 144         }
 145     }
 146     /// <summary>Method to raise event TextSelectionChangedEvt.</summary>
 147     public void OnTextSelectionChangedEvt(EventArgs e)
 148     {
 149         var key = "_EFL_TEXT_INTERACTIVE_EVENT_TEXT_SELECTION_CHANGED";
 150         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 151         if (desc == IntPtr.Zero)
 152         {
 153             Eina.Log.Error($"Failed to get native event {key}");
 154             return;
 155         }
 156
 157         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 158     }
 159     /// <summary>Whether or not selection is allowed on this object</summary>
 160     /// <returns><c>true</c> if enabled, <c>false</c> otherwise</returns>
 161     public bool GetSelectionAllowed() {
 162          var _ret_var = Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_selection_allowed_get_ptr.Value.Delegate(this.NativeHandle);
 163         Eina.Error.RaiseIfUnhandledException();
 164         return _ret_var;
 165  }
 166     /// <summary>Whether or not selection is allowed on this object</summary>
 167     /// <param name="allowed"><c>true</c> if enabled, <c>false</c> otherwise</param>
 168     public void SetSelectionAllowed(bool allowed) {
 169                                  Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_selection_allowed_set_ptr.Value.Delegate(this.NativeHandle,allowed);
 170         Eina.Error.RaiseIfUnhandledException();
 171                          }
 172     /// <summary>The cursors used for selection handling.
 173     /// If the cursors are equal there&apos;s no selection.
 174     ///
 175     /// You are allowed to retain and modify them. Modifying them modifies the selection of the object.</summary>
 176     /// <param name="start">The start of the selection</param>
 177     /// <param name="end">The end of the selection</param>
 178     public void GetSelectionCursors(out Efl.TextCursorCursor start, out Efl.TextCursorCursor end) {
 179                                                          Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_selection_cursors_get_ptr.Value.Delegate(this.NativeHandle,out start, out end);
 180         Eina.Error.RaiseIfUnhandledException();
 181                                          }
 182     /// <summary>Whether the entry is editable.
 183     /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
 184     /// <returns>If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</returns>
 185     public bool GetEditable() {
 186          var _ret_var = Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_editable_get_ptr.Value.Delegate(this.NativeHandle);
 187         Eina.Error.RaiseIfUnhandledException();
 188         return _ret_var;
 189  }
 190     /// <summary>Whether the entry is editable.
 191     /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
 192     /// <param name="editable">If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</param>
 193     public void SetEditable(bool editable) {
 194                                  Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_editable_set_ptr.Value.Delegate(this.NativeHandle,editable);
 195         Eina.Error.RaiseIfUnhandledException();
 196                          }
 197     /// <summary>Clears the selection.</summary>
 198     public void SelectNone() {
 199          Efl.ITextInteractiveConcrete.NativeMethods.efl_text_interactive_select_none_ptr.Value.Delegate(this.NativeHandle);
 200         Eina.Error.RaiseIfUnhandledException();
 201          }
 202     /// <summary>Retrieves the text string currently being displayed by the given text object.
 203     /// Do not free() the return value.
 204     ///
 205     /// See also <see cref="Efl.IText.GetText"/>.
 206     /// (Since EFL 1.22)</summary>
 207     /// <returns>Text string to display on it.</returns>
 208     public System.String GetText() {
 209          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate(this.NativeHandle);
 210         Eina.Error.RaiseIfUnhandledException();
 211         return _ret_var;
 212  }
 213     /// <summary>Sets the text string to be displayed by the given text object.
 214     /// See also <see cref="Efl.IText.GetText"/>.
 215     /// (Since EFL 1.22)</summary>
 216     /// <param name="text">Text string to display on it.</param>
 217     public void SetText(System.String text) {
 218                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate(this.NativeHandle,text);
 219         Eina.Error.RaiseIfUnhandledException();
 220                          }
 221     /// <summary>Retrieve the font family and size in use on a given text object.
 222     /// This function allows the font name and size of a text object to be queried. Remember that the font name string is still owned by Evas and should not have free() called on it by the caller of the function.
 223     ///
 224     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 225     /// <param name="font">The font family name or filename.</param>
 226     /// <param name="size">The font size, in points.</param>
 227     public void GetFont(out System.String font, out Efl.Font.Size size) {
 228                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_get_ptr.Value.Delegate(this.NativeHandle,out font, out size);
 229         Eina.Error.RaiseIfUnhandledException();
 230                                          }
 231     /// <summary>Set the font family, filename and size for a given text object.
 232     /// This function allows the font name and size of a text object to be set. The font string has to follow fontconfig&apos;s convention for naming fonts, as it&apos;s the underlying library used to query system fonts by Evas (see the fc-list command&apos;s output, on your system, to get an idea). Alternatively, youe can use the full path to a font file.
 233     ///
 234     /// To skip changing font family pass null as font family. To skip changing font size pass 0 as font size.
 235     ///
 236     /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
 237     /// <param name="font">The font family name or filename.</param>
 238     /// <param name="size">The font size, in points.</param>
 239     public void SetFont(System.String font, Efl.Font.Size size) {
 240                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_set_ptr.Value.Delegate(this.NativeHandle,font, size);
 241         Eina.Error.RaiseIfUnhandledException();
 242                                          }
 243     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 244     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 245     /// <returns>The font file&apos;s path.</returns>
 246     public System.String GetFontSource() {
 247          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_get_ptr.Value.Delegate(this.NativeHandle);
 248         Eina.Error.RaiseIfUnhandledException();
 249         return _ret_var;
 250  }
 251     /// <summary>Set the font (source) file to be used on a given text object.
 252     /// This function allows the font file to be explicitly set for a given text object, overriding system lookup, which will first occur in the given file&apos;s contents.
 253     ///
 254     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 255     /// <param name="font_source">The font file&apos;s path.</param>
 256     public void SetFontSource(System.String font_source) {
 257                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_set_ptr.Value.Delegate(this.NativeHandle,font_source);
 258         Eina.Error.RaiseIfUnhandledException();
 259                          }
 260     /// <summary>Comma-separated list of font fallbacks
 261     /// Will be used in case the primary font isn&apos;t available.</summary>
 262     /// <returns>Font name fallbacks</returns>
 263     public System.String GetFontFallbacks() {
 264          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_get_ptr.Value.Delegate(this.NativeHandle);
 265         Eina.Error.RaiseIfUnhandledException();
 266         return _ret_var;
 267  }
 268     /// <summary>Comma-separated list of font fallbacks
 269     /// Will be used in case the primary font isn&apos;t available.</summary>
 270     /// <param name="font_fallbacks">Font name fallbacks</param>
 271     public void SetFontFallbacks(System.String font_fallbacks) {
 272                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_set_ptr.Value.Delegate(this.NativeHandle,font_fallbacks);
 273         Eina.Error.RaiseIfUnhandledException();
 274                          }
 275     /// <summary>Type of weight of the displayed font
 276     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 277     /// <returns>Font weight</returns>
 278     public Efl.TextFontWeight GetFontWeight() {
 279          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_get_ptr.Value.Delegate(this.NativeHandle);
 280         Eina.Error.RaiseIfUnhandledException();
 281         return _ret_var;
 282  }
 283     /// <summary>Type of weight of the displayed font
 284     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 285     /// <param name="font_weight">Font weight</param>
 286     public void SetFontWeight(Efl.TextFontWeight font_weight) {
 287                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_set_ptr.Value.Delegate(this.NativeHandle,font_weight);
 288         Eina.Error.RaiseIfUnhandledException();
 289                          }
 290     /// <summary>Type of slant of the displayed font
 291     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 292     /// <returns>Font slant</returns>
 293     public Efl.TextFontSlant GetFontSlant() {
 294          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_get_ptr.Value.Delegate(this.NativeHandle);
 295         Eina.Error.RaiseIfUnhandledException();
 296         return _ret_var;
 297  }
 298     /// <summary>Type of slant of the displayed font
 299     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 300     /// <param name="style">Font slant</param>
 301     public void SetFontSlant(Efl.TextFontSlant style) {
 302                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_set_ptr.Value.Delegate(this.NativeHandle,style);
 303         Eina.Error.RaiseIfUnhandledException();
 304                          }
 305     /// <summary>Type of width of the displayed font
 306     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 307     /// <returns>Font width</returns>
 308     public Efl.TextFontWidth GetFontWidth() {
 309          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_get_ptr.Value.Delegate(this.NativeHandle);
 310         Eina.Error.RaiseIfUnhandledException();
 311         return _ret_var;
 312  }
 313     /// <summary>Type of width of the displayed font
 314     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 315     /// <param name="width">Font width</param>
 316     public void SetFontWidth(Efl.TextFontWidth width) {
 317                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_set_ptr.Value.Delegate(this.NativeHandle,width);
 318         Eina.Error.RaiseIfUnhandledException();
 319                          }
 320     /// <summary>Specific language of the displayed font
 321     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 322     /// <returns>Language</returns>
 323     public System.String GetFontLang() {
 324          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_get_ptr.Value.Delegate(this.NativeHandle);
 325         Eina.Error.RaiseIfUnhandledException();
 326         return _ret_var;
 327  }
 328     /// <summary>Specific language of the displayed font
 329     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 330     /// <param name="lang">Language</param>
 331     public void SetFontLang(System.String lang) {
 332                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_set_ptr.Value.Delegate(this.NativeHandle,lang);
 333         Eina.Error.RaiseIfUnhandledException();
 334                          }
 335     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 336     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 337     /// <returns>Scalable</returns>
 338     public Efl.TextFontBitmapScalable GetFontBitmapScalable() {
 339          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(this.NativeHandle);
 340         Eina.Error.RaiseIfUnhandledException();
 341         return _ret_var;
 342  }
 343     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 344     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 345     /// <param name="scalable">Scalable</param>
 346     public void SetFontBitmapScalable(Efl.TextFontBitmapScalable scalable) {
 347                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(this.NativeHandle,scalable);
 348         Eina.Error.RaiseIfUnhandledException();
 349                          }
 350     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 351     /// <returns>Ellipsis value</returns>
 352     public double GetEllipsis() {
 353          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_get_ptr.Value.Delegate(this.NativeHandle);
 354         Eina.Error.RaiseIfUnhandledException();
 355         return _ret_var;
 356  }
 357     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 358     /// <param name="value">Ellipsis value</param>
 359     public void SetEllipsis(double value) {
 360                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_set_ptr.Value.Delegate(this.NativeHandle,value);
 361         Eina.Error.RaiseIfUnhandledException();
 362                          }
 363     /// <summary>Wrap mode for use in the text</summary>
 364     /// <returns>Wrap mode</returns>
 365     public Efl.TextFormatWrap GetWrap() {
 366          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_get_ptr.Value.Delegate(this.NativeHandle);
 367         Eina.Error.RaiseIfUnhandledException();
 368         return _ret_var;
 369  }
 370     /// <summary>Wrap mode for use in the text</summary>
 371     /// <param name="wrap">Wrap mode</param>
 372     public void SetWrap(Efl.TextFormatWrap wrap) {
 373                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_set_ptr.Value.Delegate(this.NativeHandle,wrap);
 374         Eina.Error.RaiseIfUnhandledException();
 375                          }
 376     /// <summary>Multiline is enabled or not</summary>
 377     /// <returns><c>true</c> if multiline is enabled, <c>false</c> otherwise</returns>
 378     public bool GetMultiline() {
 379          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_get_ptr.Value.Delegate(this.NativeHandle);
 380         Eina.Error.RaiseIfUnhandledException();
 381         return _ret_var;
 382  }
 383     /// <summary>Multiline is enabled or not</summary>
 384     /// <param name="enabled"><c>true</c> if multiline is enabled, <c>false</c> otherwise</param>
 385     public void SetMultiline(bool enabled) {
 386                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_set_ptr.Value.Delegate(this.NativeHandle,enabled);
 387         Eina.Error.RaiseIfUnhandledException();
 388                          }
 389     /// <summary>Horizontal alignment of text</summary>
 390     /// <returns>Alignment type</returns>
 391     public Efl.TextFormatHorizontalAlignmentAutoType GetHalignAutoType() {
 392          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_get_ptr.Value.Delegate(this.NativeHandle);
 393         Eina.Error.RaiseIfUnhandledException();
 394         return _ret_var;
 395  }
 396     /// <summary>Horizontal alignment of text</summary>
 397     /// <param name="value">Alignment type</param>
 398     public void SetHalignAutoType(Efl.TextFormatHorizontalAlignmentAutoType value) {
 399                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_set_ptr.Value.Delegate(this.NativeHandle,value);
 400         Eina.Error.RaiseIfUnhandledException();
 401                          }
 402     /// <summary>Horizontal alignment of text</summary>
 403     /// <returns>Horizontal alignment value</returns>
 404     public double GetHalign() {
 405          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_get_ptr.Value.Delegate(this.NativeHandle);
 406         Eina.Error.RaiseIfUnhandledException();
 407         return _ret_var;
 408  }
 409     /// <summary>Horizontal alignment of text</summary>
 410     /// <param name="value">Horizontal alignment value</param>
 411     public void SetHalign(double value) {
 412                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_set_ptr.Value.Delegate(this.NativeHandle,value);
 413         Eina.Error.RaiseIfUnhandledException();
 414                          }
 415     /// <summary>Vertical alignment of text</summary>
 416     /// <returns>Vertical alignment value</returns>
 417     public double GetValign() {
 418          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_get_ptr.Value.Delegate(this.NativeHandle);
 419         Eina.Error.RaiseIfUnhandledException();
 420         return _ret_var;
 421  }
 422     /// <summary>Vertical alignment of text</summary>
 423     /// <param name="value">Vertical alignment value</param>
 424     public void SetValign(double value) {
 425                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_set_ptr.Value.Delegate(this.NativeHandle,value);
 426         Eina.Error.RaiseIfUnhandledException();
 427                          }
 428     /// <summary>Minimal line gap (top and bottom) for each line in the text
 429     /// <c>value</c> is absolute size.</summary>
 430     /// <returns>Line gap value</returns>
 431     public double GetLinegap() {
 432          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_get_ptr.Value.Delegate(this.NativeHandle);
 433         Eina.Error.RaiseIfUnhandledException();
 434         return _ret_var;
 435  }
 436     /// <summary>Minimal line gap (top and bottom) for each line in the text
 437     /// <c>value</c> is absolute size.</summary>
 438     /// <param name="value">Line gap value</param>
 439     public void SetLinegap(double value) {
 440                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_set_ptr.Value.Delegate(this.NativeHandle,value);
 441         Eina.Error.RaiseIfUnhandledException();
 442                          }
 443     /// <summary>Relative line gap (top and bottom) for each line in the text
 444     /// The original line gap value is multiplied by <c>value</c>.</summary>
 445     /// <returns>Relative line gap value</returns>
 446     public double GetLinerelgap() {
 447          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_get_ptr.Value.Delegate(this.NativeHandle);
 448         Eina.Error.RaiseIfUnhandledException();
 449         return _ret_var;
 450  }
 451     /// <summary>Relative line gap (top and bottom) for each line in the text
 452     /// The original line gap value is multiplied by <c>value</c>.</summary>
 453     /// <param name="value">Relative line gap value</param>
 454     public void SetLinerelgap(double value) {
 455                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_set_ptr.Value.Delegate(this.NativeHandle,value);
 456         Eina.Error.RaiseIfUnhandledException();
 457                          }
 458     /// <summary>Tabstops value</summary>
 459     /// <returns>Tapstops value</returns>
 460     public int GetTabstops() {
 461          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_get_ptr.Value.Delegate(this.NativeHandle);
 462         Eina.Error.RaiseIfUnhandledException();
 463         return _ret_var;
 464  }
 465     /// <summary>Tabstops value</summary>
 466     /// <param name="value">Tapstops value</param>
 467     public void SetTabstops(int value) {
 468                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_set_ptr.Value.Delegate(this.NativeHandle,value);
 469         Eina.Error.RaiseIfUnhandledException();
 470                          }
 471     /// <summary>Whether text is a password</summary>
 472     /// <returns><c>true</c> if the text is a password, <c>false</c> otherwise</returns>
 473     public bool GetPassword() {
 474          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_password_get_ptr.Value.Delegate(this.NativeHandle);
 475         Eina.Error.RaiseIfUnhandledException();
 476         return _ret_var;
 477  }
 478     /// <summary>Whether text is a password</summary>
 479     /// <param name="enabled"><c>true</c> if the text is a password, <c>false</c> otherwise</param>
 480     public void SetPassword(bool enabled) {
 481                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_password_set_ptr.Value.Delegate(this.NativeHandle,enabled);
 482         Eina.Error.RaiseIfUnhandledException();
 483                          }
 484     /// <summary>The character used to replace characters that can&apos;t be displayed
 485     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 486     /// <returns>Replacement character</returns>
 487     public System.String GetReplacementChar() {
 488          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_get_ptr.Value.Delegate(this.NativeHandle);
 489         Eina.Error.RaiseIfUnhandledException();
 490         return _ret_var;
 491  }
 492     /// <summary>The character used to replace characters that can&apos;t be displayed
 493     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 494     /// <param name="repch">Replacement character</param>
 495     public void SetReplacementChar(System.String repch) {
 496                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_set_ptr.Value.Delegate(this.NativeHandle,repch);
 497         Eina.Error.RaiseIfUnhandledException();
 498                          }
 499     /// <summary>Color of text, excluding style</summary>
 500     /// <param name="r">Red component</param>
 501     /// <param name="g">Green component</param>
 502     /// <param name="b">Blue component</param>
 503     /// <param name="a">Alpha component</param>
 504     public void GetNormalColor(out byte r, out byte g, out byte b, out byte a) {
 505                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 506         Eina.Error.RaiseIfUnhandledException();
 507                                                                          }
 508     /// <summary>Color of text, excluding style</summary>
 509     /// <param name="r">Red component</param>
 510     /// <param name="g">Green component</param>
 511     /// <param name="b">Blue component</param>
 512     /// <param name="a">Alpha component</param>
 513     public void SetNormalColor(byte r, byte g, byte b, byte a) {
 514                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 515         Eina.Error.RaiseIfUnhandledException();
 516                                                                          }
 517     /// <summary>Enable or disable backing type</summary>
 518     /// <returns>Backing type</returns>
 519     public Efl.TextStyleBackingType GetBackingType() {
 520          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_get_ptr.Value.Delegate(this.NativeHandle);
 521         Eina.Error.RaiseIfUnhandledException();
 522         return _ret_var;
 523  }
 524     /// <summary>Enable or disable backing type</summary>
 525     /// <param name="type">Backing type</param>
 526     public void SetBackingType(Efl.TextStyleBackingType type) {
 527                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 528         Eina.Error.RaiseIfUnhandledException();
 529                          }
 530     /// <summary>Backing color</summary>
 531     /// <param name="r">Red component</param>
 532     /// <param name="g">Green component</param>
 533     /// <param name="b">Blue component</param>
 534     /// <param name="a">Alpha component</param>
 535     public void GetBackingColor(out byte r, out byte g, out byte b, out byte a) {
 536                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 537         Eina.Error.RaiseIfUnhandledException();
 538                                                                          }
 539     /// <summary>Backing color</summary>
 540     /// <param name="r">Red component</param>
 541     /// <param name="g">Green component</param>
 542     /// <param name="b">Blue component</param>
 543     /// <param name="a">Alpha component</param>
 544     public void SetBackingColor(byte r, byte g, byte b, byte a) {
 545                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 546         Eina.Error.RaiseIfUnhandledException();
 547                                                                          }
 548     /// <summary>Sets an underline style on the text</summary>
 549     /// <returns>Underline type</returns>
 550     public Efl.TextStyleUnderlineType GetUnderlineType() {
 551          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_get_ptr.Value.Delegate(this.NativeHandle);
 552         Eina.Error.RaiseIfUnhandledException();
 553         return _ret_var;
 554  }
 555     /// <summary>Sets an underline style on the text</summary>
 556     /// <param name="type">Underline type</param>
 557     public void SetUnderlineType(Efl.TextStyleUnderlineType type) {
 558                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 559         Eina.Error.RaiseIfUnhandledException();
 560                          }
 561     /// <summary>Color of normal underline style</summary>
 562     /// <param name="r">Red component</param>
 563     /// <param name="g">Green component</param>
 564     /// <param name="b">Blue component</param>
 565     /// <param name="a">Alpha component</param>
 566     public void GetUnderlineColor(out byte r, out byte g, out byte b, out byte a) {
 567                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 568         Eina.Error.RaiseIfUnhandledException();
 569                                                                          }
 570     /// <summary>Color of normal underline style</summary>
 571     /// <param name="r">Red component</param>
 572     /// <param name="g">Green component</param>
 573     /// <param name="b">Blue component</param>
 574     /// <param name="a">Alpha component</param>
 575     public void SetUnderlineColor(byte r, byte g, byte b, byte a) {
 576                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 577         Eina.Error.RaiseIfUnhandledException();
 578                                                                          }
 579     /// <summary>Height of underline style</summary>
 580     /// <returns>Height</returns>
 581     public double GetUnderlineHeight() {
 582          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_get_ptr.Value.Delegate(this.NativeHandle);
 583         Eina.Error.RaiseIfUnhandledException();
 584         return _ret_var;
 585  }
 586     /// <summary>Height of underline style</summary>
 587     /// <param name="height">Height</param>
 588     public void SetUnderlineHeight(double height) {
 589                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_set_ptr.Value.Delegate(this.NativeHandle,height);
 590         Eina.Error.RaiseIfUnhandledException();
 591                          }
 592     /// <summary>Color of dashed underline style</summary>
 593     /// <param name="r">Red component</param>
 594     /// <param name="g">Green component</param>
 595     /// <param name="b">Blue component</param>
 596     /// <param name="a">Alpha component</param>
 597     public void GetUnderlineDashedColor(out byte r, out byte g, out byte b, out byte a) {
 598                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 599         Eina.Error.RaiseIfUnhandledException();
 600                                                                          }
 601     /// <summary>Color of dashed underline style</summary>
 602     /// <param name="r">Red component</param>
 603     /// <param name="g">Green component</param>
 604     /// <param name="b">Blue component</param>
 605     /// <param name="a">Alpha component</param>
 606     public void SetUnderlineDashedColor(byte r, byte g, byte b, byte a) {
 607                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 608         Eina.Error.RaiseIfUnhandledException();
 609                                                                          }
 610     /// <summary>Width of dashed underline style</summary>
 611     /// <returns>Width</returns>
 612     public int GetUnderlineDashedWidth() {
 613          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_get_ptr.Value.Delegate(this.NativeHandle);
 614         Eina.Error.RaiseIfUnhandledException();
 615         return _ret_var;
 616  }
 617     /// <summary>Width of dashed underline style</summary>
 618     /// <param name="width">Width</param>
 619     public void SetUnderlineDashedWidth(int width) {
 620                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_set_ptr.Value.Delegate(this.NativeHandle,width);
 621         Eina.Error.RaiseIfUnhandledException();
 622                          }
 623     /// <summary>Gap of dashed underline style</summary>
 624     /// <returns>Gap</returns>
 625     public int GetUnderlineDashedGap() {
 626          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_get_ptr.Value.Delegate(this.NativeHandle);
 627         Eina.Error.RaiseIfUnhandledException();
 628         return _ret_var;
 629  }
 630     /// <summary>Gap of dashed underline style</summary>
 631     /// <param name="gap">Gap</param>
 632     public void SetUnderlineDashedGap(int gap) {
 633                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_set_ptr.Value.Delegate(this.NativeHandle,gap);
 634         Eina.Error.RaiseIfUnhandledException();
 635                          }
 636     /// <summary>Color of underline2 style</summary>
 637     /// <param name="r">Red component</param>
 638     /// <param name="g">Green component</param>
 639     /// <param name="b">Blue component</param>
 640     /// <param name="a">Alpha component</param>
 641     public void GetUnderline2Color(out byte r, out byte g, out byte b, out byte a) {
 642                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 643         Eina.Error.RaiseIfUnhandledException();
 644                                                                          }
 645     /// <summary>Color of underline2 style</summary>
 646     /// <param name="r">Red component</param>
 647     /// <param name="g">Green component</param>
 648     /// <param name="b">Blue component</param>
 649     /// <param name="a">Alpha component</param>
 650     public void SetUnderline2Color(byte r, byte g, byte b, byte a) {
 651                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 652         Eina.Error.RaiseIfUnhandledException();
 653                                                                          }
 654     /// <summary>Type of strikethrough style</summary>
 655     /// <returns>Strikethrough type</returns>
 656     public Efl.TextStyleStrikethroughType GetStrikethroughType() {
 657          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_get_ptr.Value.Delegate(this.NativeHandle);
 658         Eina.Error.RaiseIfUnhandledException();
 659         return _ret_var;
 660  }
 661     /// <summary>Type of strikethrough style</summary>
 662     /// <param name="type">Strikethrough type</param>
 663     public void SetStrikethroughType(Efl.TextStyleStrikethroughType type) {
 664                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 665         Eina.Error.RaiseIfUnhandledException();
 666                          }
 667     /// <summary>Color of strikethrough_style</summary>
 668     /// <param name="r">Red component</param>
 669     /// <param name="g">Green component</param>
 670     /// <param name="b">Blue component</param>
 671     /// <param name="a">Alpha component</param>
 672     public void GetStrikethroughColor(out byte r, out byte g, out byte b, out byte a) {
 673                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 674         Eina.Error.RaiseIfUnhandledException();
 675                                                                          }
 676     /// <summary>Color of strikethrough_style</summary>
 677     /// <param name="r">Red component</param>
 678     /// <param name="g">Green component</param>
 679     /// <param name="b">Blue component</param>
 680     /// <param name="a">Alpha component</param>
 681     public void SetStrikethroughColor(byte r, byte g, byte b, byte a) {
 682                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 683         Eina.Error.RaiseIfUnhandledException();
 684                                                                          }
 685     /// <summary>Type of effect used for the displayed text</summary>
 686     /// <returns>Effect type</returns>
 687     public Efl.TextStyleEffectType GetEffectType() {
 688          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_get_ptr.Value.Delegate(this.NativeHandle);
 689         Eina.Error.RaiseIfUnhandledException();
 690         return _ret_var;
 691  }
 692     /// <summary>Type of effect used for the displayed text</summary>
 693     /// <param name="type">Effect type</param>
 694     public void SetEffectType(Efl.TextStyleEffectType type) {
 695                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_set_ptr.Value.Delegate(this.NativeHandle,type);
 696         Eina.Error.RaiseIfUnhandledException();
 697                          }
 698     /// <summary>Color of outline effect</summary>
 699     /// <param name="r">Red component</param>
 700     /// <param name="g">Green component</param>
 701     /// <param name="b">Blue component</param>
 702     /// <param name="a">Alpha component</param>
 703     public void GetOutlineColor(out byte r, out byte g, out byte b, out byte a) {
 704                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 705         Eina.Error.RaiseIfUnhandledException();
 706                                                                          }
 707     /// <summary>Color of outline effect</summary>
 708     /// <param name="r">Red component</param>
 709     /// <param name="g">Green component</param>
 710     /// <param name="b">Blue component</param>
 711     /// <param name="a">Alpha component</param>
 712     public void SetOutlineColor(byte r, byte g, byte b, byte a) {
 713                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 714         Eina.Error.RaiseIfUnhandledException();
 715                                                                          }
 716     /// <summary>Direction of shadow effect</summary>
 717     /// <returns>Shadow direction</returns>
 718     public Efl.TextStyleShadowDirection GetShadowDirection() {
 719          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_get_ptr.Value.Delegate(this.NativeHandle);
 720         Eina.Error.RaiseIfUnhandledException();
 721         return _ret_var;
 722  }
 723     /// <summary>Direction of shadow effect</summary>
 724     /// <param name="type">Shadow direction</param>
 725     public void SetShadowDirection(Efl.TextStyleShadowDirection type) {
 726                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_set_ptr.Value.Delegate(this.NativeHandle,type);
 727         Eina.Error.RaiseIfUnhandledException();
 728                          }
 729     /// <summary>Color of shadow effect</summary>
 730     /// <param name="r">Red component</param>
 731     /// <param name="g">Green component</param>
 732     /// <param name="b">Blue component</param>
 733     /// <param name="a">Alpha component</param>
 734     public void GetShadowColor(out byte r, out byte g, out byte b, out byte a) {
 735                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 736         Eina.Error.RaiseIfUnhandledException();
 737                                                                          }
 738     /// <summary>Color of shadow effect</summary>
 739     /// <param name="r">Red component</param>
 740     /// <param name="g">Green component</param>
 741     /// <param name="b">Blue component</param>
 742     /// <param name="a">Alpha component</param>
 743     public void SetShadowColor(byte r, byte g, byte b, byte a) {
 744                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 745         Eina.Error.RaiseIfUnhandledException();
 746                                                                          }
 747     /// <summary>Color of glow effect</summary>
 748     /// <param name="r">Red component</param>
 749     /// <param name="g">Green component</param>
 750     /// <param name="b">Blue component</param>
 751     /// <param name="a">Alpha component</param>
 752     public void GetGlowColor(out byte r, out byte g, out byte b, out byte a) {
 753                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 754         Eina.Error.RaiseIfUnhandledException();
 755                                                                          }
 756     /// <summary>Color of glow effect</summary>
 757     /// <param name="r">Red component</param>
 758     /// <param name="g">Green component</param>
 759     /// <param name="b">Blue component</param>
 760     /// <param name="a">Alpha component</param>
 761     public void SetGlowColor(byte r, byte g, byte b, byte a) {
 762                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 763         Eina.Error.RaiseIfUnhandledException();
 764                                                                          }
 765     /// <summary>Second color of the glow effect</summary>
 766     /// <param name="r">Red component</param>
 767     /// <param name="g">Green component</param>
 768     /// <param name="b">Blue component</param>
 769     /// <param name="a">Alpha component</param>
 770     public void GetGlow2Color(out byte r, out byte g, out byte b, out byte a) {
 771                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 772         Eina.Error.RaiseIfUnhandledException();
 773                                                                          }
 774     /// <summary>Second color of the glow effect</summary>
 775     /// <param name="r">Red component</param>
 776     /// <param name="g">Green component</param>
 777     /// <param name="b">Blue component</param>
 778     /// <param name="a">Alpha component</param>
 779     public void SetGlow2Color(byte r, byte g, byte b, byte a) {
 780                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 781         Eina.Error.RaiseIfUnhandledException();
 782                                                                          }
 783     /// <summary>Program that applies a special filter
 784     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 785     /// <returns>Filter code</returns>
 786     public System.String GetGfxFilter() {
 787          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_get_ptr.Value.Delegate(this.NativeHandle);
 788         Eina.Error.RaiseIfUnhandledException();
 789         return _ret_var;
 790  }
 791     /// <summary>Program that applies a special filter
 792     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 793     /// <param name="code">Filter code</param>
 794     public void SetGfxFilter(System.String code) {
 795                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_set_ptr.Value.Delegate(this.NativeHandle,code);
 796         Eina.Error.RaiseIfUnhandledException();
 797                          }
 798     /// <summary>Whether or not selection is allowed on this object</summary>
 799     /// <value><c>true</c> if enabled, <c>false</c> otherwise</value>
 800     public bool SelectionAllowed {
 801         get { return GetSelectionAllowed(); }
 802         set { SetSelectionAllowed(value); }
 803     }
 804     /// <summary>The cursors used for selection handling.
 805     /// If the cursors are equal there&apos;s no selection.
 806     ///
 807     /// You are allowed to retain and modify them. Modifying them modifies the selection of the object.</summary>
 808     public (Efl.TextCursorCursor, Efl.TextCursorCursor) SelectionCursors {
 809         get {
 810             Efl.TextCursorCursor _out_start = default(Efl.TextCursorCursor);
 811             Efl.TextCursorCursor _out_end = default(Efl.TextCursorCursor);
 812             GetSelectionCursors(out _out_start,out _out_end);
 813             return (_out_start,_out_end);
 814         }
 815     }
 816     /// <summary>Whether the entry is editable.
 817     /// By default text interactives are editable. However setting this property to <c>false</c> will make it so that key input will be disregarded.</summary>
 818     /// <value>If <c>true</c>, user input will be inserted in the entry, if not, the entry is read-only and no user input is allowed.</value>
 819     public bool Editable {
 820         get { return GetEditable(); }
 821         set { SetEditable(value); }
 822     }
 823     /// <summary>Retrieve the font family and size in use on a given text object.
 824     /// This function allows the font name and size of a text object to be queried. Remember that the font name string is still owned by Evas and should not have free() called on it by the caller of the function.
 825     ///
 826     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 827     /// <value>The font family name or filename.</value>
 828     public (System.String, Efl.Font.Size) Font {
 829         get {
 830             System.String _out_font = default(System.String);
 831             Efl.Font.Size _out_size = default(Efl.Font.Size);
 832             GetFont(out _out_font,out _out_size);
 833             return (_out_font,_out_size);
 834         }
 835         set { SetFont( value.Item1,  value.Item2); }
 836     }
 837     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 838     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 839     /// <value>The font file&apos;s path.</value>
 840     public System.String FontSource {
 841         get { return GetFontSource(); }
 842         set { SetFontSource(value); }
 843     }
 844     /// <summary>Comma-separated list of font fallbacks
 845     /// Will be used in case the primary font isn&apos;t available.</summary>
 846     /// <value>Font name fallbacks</value>
 847     public System.String FontFallbacks {
 848         get { return GetFontFallbacks(); }
 849         set { SetFontFallbacks(value); }
 850     }
 851     /// <summary>Type of weight of the displayed font
 852     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 853     /// <value>Font weight</value>
 854     public Efl.TextFontWeight FontWeight {
 855         get { return GetFontWeight(); }
 856         set { SetFontWeight(value); }
 857     }
 858     /// <summary>Type of slant of the displayed font
 859     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 860     /// <value>Font slant</value>
 861     public Efl.TextFontSlant FontSlant {
 862         get { return GetFontSlant(); }
 863         set { SetFontSlant(value); }
 864     }
 865     /// <summary>Type of width of the displayed font
 866     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 867     /// <value>Font width</value>
 868     public Efl.TextFontWidth FontWidth {
 869         get { return GetFontWidth(); }
 870         set { SetFontWidth(value); }
 871     }
 872     /// <summary>Specific language of the displayed font
 873     /// This is used to lookup fonts suitable to the specified language, as well as helping the font shaper backend. The language <c>lang</c> can be either a code e.g &quot;en_US&quot;, &quot;auto&quot; to use the system locale, or &quot;none&quot;.</summary>
 874     /// <value>Language</value>
 875     public System.String FontLang {
 876         get { return GetFontLang(); }
 877         set { SetFontLang(value); }
 878     }
 879     /// <summary>The bitmap fonts have fixed size glyphs for several available sizes. Basically, it is not scalable. But, it needs to be scalable for some use cases. (ex. colorful emoji fonts)
 880     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 881     /// <value>Scalable</value>
 882     public Efl.TextFontBitmapScalable FontBitmapScalable {
 883         get { return GetFontBitmapScalable(); }
 884         set { SetFontBitmapScalable(value); }
 885     }
 886     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 887     /// <value>Ellipsis value</value>
 888     public double Ellipsis {
 889         get { return GetEllipsis(); }
 890         set { SetEllipsis(value); }
 891     }
 892     /// <summary>Wrap mode for use in the text</summary>
 893     /// <value>Wrap mode</value>
 894     public Efl.TextFormatWrap Wrap {
 895         get { return GetWrap(); }
 896         set { SetWrap(value); }
 897     }
 898     /// <summary>Multiline is enabled or not</summary>
 899     /// <value><c>true</c> if multiline is enabled, <c>false</c> otherwise</value>
 900     public bool Multiline {
 901         get { return GetMultiline(); }
 902         set { SetMultiline(value); }
 903     }
 904     /// <summary>Horizontal alignment of text</summary>
 905     /// <value>Alignment type</value>
 906     public Efl.TextFormatHorizontalAlignmentAutoType HalignAutoType {
 907         get { return GetHalignAutoType(); }
 908         set { SetHalignAutoType(value); }
 909     }
 910     /// <summary>Horizontal alignment of text</summary>
 911     /// <value>Horizontal alignment value</value>
 912     public double Halign {
 913         get { return GetHalign(); }
 914         set { SetHalign(value); }
 915     }
 916     /// <summary>Vertical alignment of text</summary>
 917     /// <value>Vertical alignment value</value>
 918     public double Valign {
 919         get { return GetValign(); }
 920         set { SetValign(value); }
 921     }
 922     /// <summary>Minimal line gap (top and bottom) for each line in the text
 923     /// <c>value</c> is absolute size.</summary>
 924     /// <value>Line gap value</value>
 925     public double Linegap {
 926         get { return GetLinegap(); }
 927         set { SetLinegap(value); }
 928     }
 929     /// <summary>Relative line gap (top and bottom) for each line in the text
 930     /// The original line gap value is multiplied by <c>value</c>.</summary>
 931     /// <value>Relative line gap value</value>
 932     public double Linerelgap {
 933         get { return GetLinerelgap(); }
 934         set { SetLinerelgap(value); }
 935     }
 936     /// <summary>Tabstops value</summary>
 937     /// <value>Tapstops value</value>
 938     public int Tabstops {
 939         get { return GetTabstops(); }
 940         set { SetTabstops(value); }
 941     }
 942     /// <summary>Whether text is a password</summary>
 943     /// <value><c>true</c> if the text is a password, <c>false</c> otherwise</value>
 944     public bool Password {
 945         get { return GetPassword(); }
 946         set { SetPassword(value); }
 947     }
 948     /// <summary>The character used to replace characters that can&apos;t be displayed
 949     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 950     /// <value>Replacement character</value>
 951     public System.String ReplacementChar {
 952         get { return GetReplacementChar(); }
 953         set { SetReplacementChar(value); }
 954     }
 955     /// <summary>Color of text, excluding style</summary>
 956     /// <value>Red component</value>
 957     public (byte, byte, byte, byte) NormalColor {
 958         get {
 959             byte _out_r = default(byte);
 960             byte _out_g = default(byte);
 961             byte _out_b = default(byte);
 962             byte _out_a = default(byte);
 963             GetNormalColor(out _out_r,out _out_g,out _out_b,out _out_a);
 964             return (_out_r,_out_g,_out_b,_out_a);
 965         }
 966         set { SetNormalColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 967     }
 968     /// <summary>Enable or disable backing type</summary>
 969     /// <value>Backing type</value>
 970     public Efl.TextStyleBackingType BackingType {
 971         get { return GetBackingType(); }
 972         set { SetBackingType(value); }
 973     }
 974     /// <summary>Backing color</summary>
 975     /// <value>Red component</value>
 976     public (byte, byte, byte, byte) BackingColor {
 977         get {
 978             byte _out_r = default(byte);
 979             byte _out_g = default(byte);
 980             byte _out_b = default(byte);
 981             byte _out_a = default(byte);
 982             GetBackingColor(out _out_r,out _out_g,out _out_b,out _out_a);
 983             return (_out_r,_out_g,_out_b,_out_a);
 984         }
 985         set { SetBackingColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 986     }
 987     /// <summary>Sets an underline style on the text</summary>
 988     /// <value>Underline type</value>
 989     public Efl.TextStyleUnderlineType UnderlineType {
 990         get { return GetUnderlineType(); }
 991         set { SetUnderlineType(value); }
 992     }
 993     /// <summary>Color of normal underline style</summary>
 994     /// <value>Red component</value>
 995     public (byte, byte, byte, byte) UnderlineColor {
 996         get {
 997             byte _out_r = default(byte);
 998             byte _out_g = default(byte);
 999             byte _out_b = default(byte);
1000             byte _out_a = default(byte);
1001             GetUnderlineColor(out _out_r,out _out_g,out _out_b,out _out_a);
1002             return (_out_r,_out_g,_out_b,_out_a);
1003         }
1004         set { SetUnderlineColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1005     }
1006     /// <summary>Height of underline style</summary>
1007     /// <value>Height</value>
1008     public double UnderlineHeight {
1009         get { return GetUnderlineHeight(); }
1010         set { SetUnderlineHeight(value); }
1011     }
1012     /// <summary>Color of dashed underline style</summary>
1013     /// <value>Red component</value>
1014     public (byte, byte, byte, byte) UnderlineDashedColor {
1015         get {
1016             byte _out_r = default(byte);
1017             byte _out_g = default(byte);
1018             byte _out_b = default(byte);
1019             byte _out_a = default(byte);
1020             GetUnderlineDashedColor(out _out_r,out _out_g,out _out_b,out _out_a);
1021             return (_out_r,_out_g,_out_b,_out_a);
1022         }
1023         set { SetUnderlineDashedColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1024     }
1025     /// <summary>Width of dashed underline style</summary>
1026     /// <value>Width</value>
1027     public int UnderlineDashedWidth {
1028         get { return GetUnderlineDashedWidth(); }
1029         set { SetUnderlineDashedWidth(value); }
1030     }
1031     /// <summary>Gap of dashed underline style</summary>
1032     /// <value>Gap</value>
1033     public int UnderlineDashedGap {
1034         get { return GetUnderlineDashedGap(); }
1035         set { SetUnderlineDashedGap(value); }
1036     }
1037     /// <summary>Color of underline2 style</summary>
1038     /// <value>Red component</value>
1039     public (byte, byte, byte, byte) Underline2Color {
1040         get {
1041             byte _out_r = default(byte);
1042             byte _out_g = default(byte);
1043             byte _out_b = default(byte);
1044             byte _out_a = default(byte);
1045             GetUnderline2Color(out _out_r,out _out_g,out _out_b,out _out_a);
1046             return (_out_r,_out_g,_out_b,_out_a);
1047         }
1048         set { SetUnderline2Color( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1049     }
1050     /// <summary>Type of strikethrough style</summary>
1051     /// <value>Strikethrough type</value>
1052     public Efl.TextStyleStrikethroughType StrikethroughType {
1053         get { return GetStrikethroughType(); }
1054         set { SetStrikethroughType(value); }
1055     }
1056     /// <summary>Color of strikethrough_style</summary>
1057     /// <value>Red component</value>
1058     public (byte, byte, byte, byte) StrikethroughColor {
1059         get {
1060             byte _out_r = default(byte);
1061             byte _out_g = default(byte);
1062             byte _out_b = default(byte);
1063             byte _out_a = default(byte);
1064             GetStrikethroughColor(out _out_r,out _out_g,out _out_b,out _out_a);
1065             return (_out_r,_out_g,_out_b,_out_a);
1066         }
1067         set { SetStrikethroughColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1068     }
1069     /// <summary>Type of effect used for the displayed text</summary>
1070     /// <value>Effect type</value>
1071     public Efl.TextStyleEffectType EffectType {
1072         get { return GetEffectType(); }
1073         set { SetEffectType(value); }
1074     }
1075     /// <summary>Color of outline effect</summary>
1076     /// <value>Red component</value>
1077     public (byte, byte, byte, byte) OutlineColor {
1078         get {
1079             byte _out_r = default(byte);
1080             byte _out_g = default(byte);
1081             byte _out_b = default(byte);
1082             byte _out_a = default(byte);
1083             GetOutlineColor(out _out_r,out _out_g,out _out_b,out _out_a);
1084             return (_out_r,_out_g,_out_b,_out_a);
1085         }
1086         set { SetOutlineColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1087     }
1088     /// <summary>Direction of shadow effect</summary>
1089     /// <value>Shadow direction</value>
1090     public Efl.TextStyleShadowDirection ShadowDirection {
1091         get { return GetShadowDirection(); }
1092         set { SetShadowDirection(value); }
1093     }
1094     /// <summary>Color of shadow effect</summary>
1095     /// <value>Red component</value>
1096     public (byte, byte, byte, byte) ShadowColor {
1097         get {
1098             byte _out_r = default(byte);
1099             byte _out_g = default(byte);
1100             byte _out_b = default(byte);
1101             byte _out_a = default(byte);
1102             GetShadowColor(out _out_r,out _out_g,out _out_b,out _out_a);
1103             return (_out_r,_out_g,_out_b,_out_a);
1104         }
1105         set { SetShadowColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1106     }
1107     /// <summary>Color of glow effect</summary>
1108     /// <value>Red component</value>
1109     public (byte, byte, byte, byte) GlowColor {
1110         get {
1111             byte _out_r = default(byte);
1112             byte _out_g = default(byte);
1113             byte _out_b = default(byte);
1114             byte _out_a = default(byte);
1115             GetGlowColor(out _out_r,out _out_g,out _out_b,out _out_a);
1116             return (_out_r,_out_g,_out_b,_out_a);
1117         }
1118         set { SetGlowColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1119     }
1120     /// <summary>Second color of the glow effect</summary>
1121     /// <value>Red component</value>
1122     public (byte, byte, byte, byte) Glow2Color {
1123         get {
1124             byte _out_r = default(byte);
1125             byte _out_g = default(byte);
1126             byte _out_b = default(byte);
1127             byte _out_a = default(byte);
1128             GetGlow2Color(out _out_r,out _out_g,out _out_b,out _out_a);
1129             return (_out_r,_out_g,_out_b,_out_a);
1130         }
1131         set { SetGlow2Color( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
1132     }
1133     /// <summary>Program that applies a special filter
1134     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
1135     /// <value>Filter code</value>
1136     public System.String GfxFilter {
1137         get { return GetGfxFilter(); }
1138         set { SetGfxFilter(value); }
1139     }
1140     private static IntPtr GetEflClassStatic()
1141     {
1142         return Efl.ITextInteractiveConcrete.efl_text_interactive_interface_get();
1143     }
1144     /// <summary>Wrapper for native methods and virtual method delegates.
1145     /// For internal use by generated code only.</summary>
1146     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
1147     {
1148         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
1149         /// <summary>Gets the list of Eo operations to override.</summary>
1150         /// <returns>The list of Eo operations to be overload.</returns>
1151         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1152         {
1153             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1154             var methods = Efl.Eo.Globals.GetUserMethods(type);
1155
1156             if (efl_text_interactive_selection_allowed_get_static_delegate == null)
1157             {
1158                 efl_text_interactive_selection_allowed_get_static_delegate = new efl_text_interactive_selection_allowed_get_delegate(selection_allowed_get);
1159             }
1160
1161             if (methods.FirstOrDefault(m => m.Name == "GetSelectionAllowed") != null)
1162             {
1163                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_selection_allowed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_selection_allowed_get_static_delegate) });
1164             }
1165
1166             if (efl_text_interactive_selection_allowed_set_static_delegate == null)
1167             {
1168                 efl_text_interactive_selection_allowed_set_static_delegate = new efl_text_interactive_selection_allowed_set_delegate(selection_allowed_set);
1169             }
1170
1171             if (methods.FirstOrDefault(m => m.Name == "SetSelectionAllowed") != null)
1172             {
1173                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_selection_allowed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_selection_allowed_set_static_delegate) });
1174             }
1175
1176             if (efl_text_interactive_selection_cursors_get_static_delegate == null)
1177             {
1178                 efl_text_interactive_selection_cursors_get_static_delegate = new efl_text_interactive_selection_cursors_get_delegate(selection_cursors_get);
1179             }
1180
1181             if (methods.FirstOrDefault(m => m.Name == "GetSelectionCursors") != null)
1182             {
1183                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_selection_cursors_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_selection_cursors_get_static_delegate) });
1184             }
1185
1186             if (efl_text_interactive_editable_get_static_delegate == null)
1187             {
1188                 efl_text_interactive_editable_get_static_delegate = new efl_text_interactive_editable_get_delegate(editable_get);
1189             }
1190
1191             if (methods.FirstOrDefault(m => m.Name == "GetEditable") != null)
1192             {
1193                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_editable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_editable_get_static_delegate) });
1194             }
1195
1196             if (efl_text_interactive_editable_set_static_delegate == null)
1197             {
1198                 efl_text_interactive_editable_set_static_delegate = new efl_text_interactive_editable_set_delegate(editable_set);
1199             }
1200
1201             if (methods.FirstOrDefault(m => m.Name == "SetEditable") != null)
1202             {
1203                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_editable_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_editable_set_static_delegate) });
1204             }
1205
1206             if (efl_text_interactive_select_none_static_delegate == null)
1207             {
1208                 efl_text_interactive_select_none_static_delegate = new efl_text_interactive_select_none_delegate(select_none);
1209             }
1210
1211             if (methods.FirstOrDefault(m => m.Name == "SelectNone") != null)
1212             {
1213                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_interactive_select_none"), func = Marshal.GetFunctionPointerForDelegate(efl_text_interactive_select_none_static_delegate) });
1214             }
1215
1216             if (efl_text_get_static_delegate == null)
1217             {
1218                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
1219             }
1220
1221             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
1222             {
1223                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
1224             }
1225
1226             if (efl_text_set_static_delegate == null)
1227             {
1228                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
1229             }
1230
1231             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
1232             {
1233                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
1234             }
1235
1236             if (efl_text_font_get_static_delegate == null)
1237             {
1238                 efl_text_font_get_static_delegate = new efl_text_font_get_delegate(font_get);
1239             }
1240
1241             if (methods.FirstOrDefault(m => m.Name == "GetFont") != null)
1242             {
1243                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_get_static_delegate) });
1244             }
1245
1246             if (efl_text_font_set_static_delegate == null)
1247             {
1248                 efl_text_font_set_static_delegate = new efl_text_font_set_delegate(font_set);
1249             }
1250
1251             if (methods.FirstOrDefault(m => m.Name == "SetFont") != null)
1252             {
1253                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_set_static_delegate) });
1254             }
1255
1256             if (efl_text_font_source_get_static_delegate == null)
1257             {
1258                 efl_text_font_source_get_static_delegate = new efl_text_font_source_get_delegate(font_source_get);
1259             }
1260
1261             if (methods.FirstOrDefault(m => m.Name == "GetFontSource") != null)
1262             {
1263                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_source_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_source_get_static_delegate) });
1264             }
1265
1266             if (efl_text_font_source_set_static_delegate == null)
1267             {
1268                 efl_text_font_source_set_static_delegate = new efl_text_font_source_set_delegate(font_source_set);
1269             }
1270
1271             if (methods.FirstOrDefault(m => m.Name == "SetFontSource") != null)
1272             {
1273                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_source_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_source_set_static_delegate) });
1274             }
1275
1276             if (efl_text_font_fallbacks_get_static_delegate == null)
1277             {
1278                 efl_text_font_fallbacks_get_static_delegate = new efl_text_font_fallbacks_get_delegate(font_fallbacks_get);
1279             }
1280
1281             if (methods.FirstOrDefault(m => m.Name == "GetFontFallbacks") != null)
1282             {
1283                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_fallbacks_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_fallbacks_get_static_delegate) });
1284             }
1285
1286             if (efl_text_font_fallbacks_set_static_delegate == null)
1287             {
1288                 efl_text_font_fallbacks_set_static_delegate = new efl_text_font_fallbacks_set_delegate(font_fallbacks_set);
1289             }
1290
1291             if (methods.FirstOrDefault(m => m.Name == "SetFontFallbacks") != null)
1292             {
1293                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_fallbacks_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_fallbacks_set_static_delegate) });
1294             }
1295
1296             if (efl_text_font_weight_get_static_delegate == null)
1297             {
1298                 efl_text_font_weight_get_static_delegate = new efl_text_font_weight_get_delegate(font_weight_get);
1299             }
1300
1301             if (methods.FirstOrDefault(m => m.Name == "GetFontWeight") != null)
1302             {
1303                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_weight_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_weight_get_static_delegate) });
1304             }
1305
1306             if (efl_text_font_weight_set_static_delegate == null)
1307             {
1308                 efl_text_font_weight_set_static_delegate = new efl_text_font_weight_set_delegate(font_weight_set);
1309             }
1310
1311             if (methods.FirstOrDefault(m => m.Name == "SetFontWeight") != null)
1312             {
1313                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_weight_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_weight_set_static_delegate) });
1314             }
1315
1316             if (efl_text_font_slant_get_static_delegate == null)
1317             {
1318                 efl_text_font_slant_get_static_delegate = new efl_text_font_slant_get_delegate(font_slant_get);
1319             }
1320
1321             if (methods.FirstOrDefault(m => m.Name == "GetFontSlant") != null)
1322             {
1323                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_slant_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_slant_get_static_delegate) });
1324             }
1325
1326             if (efl_text_font_slant_set_static_delegate == null)
1327             {
1328                 efl_text_font_slant_set_static_delegate = new efl_text_font_slant_set_delegate(font_slant_set);
1329             }
1330
1331             if (methods.FirstOrDefault(m => m.Name == "SetFontSlant") != null)
1332             {
1333                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_slant_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_slant_set_static_delegate) });
1334             }
1335
1336             if (efl_text_font_width_get_static_delegate == null)
1337             {
1338                 efl_text_font_width_get_static_delegate = new efl_text_font_width_get_delegate(font_width_get);
1339             }
1340
1341             if (methods.FirstOrDefault(m => m.Name == "GetFontWidth") != null)
1342             {
1343                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_width_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_width_get_static_delegate) });
1344             }
1345
1346             if (efl_text_font_width_set_static_delegate == null)
1347             {
1348                 efl_text_font_width_set_static_delegate = new efl_text_font_width_set_delegate(font_width_set);
1349             }
1350
1351             if (methods.FirstOrDefault(m => m.Name == "SetFontWidth") != null)
1352             {
1353                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_width_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_width_set_static_delegate) });
1354             }
1355
1356             if (efl_text_font_lang_get_static_delegate == null)
1357             {
1358                 efl_text_font_lang_get_static_delegate = new efl_text_font_lang_get_delegate(font_lang_get);
1359             }
1360
1361             if (methods.FirstOrDefault(m => m.Name == "GetFontLang") != null)
1362             {
1363                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_lang_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_lang_get_static_delegate) });
1364             }
1365
1366             if (efl_text_font_lang_set_static_delegate == null)
1367             {
1368                 efl_text_font_lang_set_static_delegate = new efl_text_font_lang_set_delegate(font_lang_set);
1369             }
1370
1371             if (methods.FirstOrDefault(m => m.Name == "SetFontLang") != null)
1372             {
1373                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_lang_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_lang_set_static_delegate) });
1374             }
1375
1376             if (efl_text_font_bitmap_scalable_get_static_delegate == null)
1377             {
1378                 efl_text_font_bitmap_scalable_get_static_delegate = new efl_text_font_bitmap_scalable_get_delegate(font_bitmap_scalable_get);
1379             }
1380
1381             if (methods.FirstOrDefault(m => m.Name == "GetFontBitmapScalable") != null)
1382             {
1383                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_bitmap_scalable_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_bitmap_scalable_get_static_delegate) });
1384             }
1385
1386             if (efl_text_font_bitmap_scalable_set_static_delegate == null)
1387             {
1388                 efl_text_font_bitmap_scalable_set_static_delegate = new efl_text_font_bitmap_scalable_set_delegate(font_bitmap_scalable_set);
1389             }
1390
1391             if (methods.FirstOrDefault(m => m.Name == "SetFontBitmapScalable") != null)
1392             {
1393                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_font_bitmap_scalable_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_font_bitmap_scalable_set_static_delegate) });
1394             }
1395
1396             if (efl_text_ellipsis_get_static_delegate == null)
1397             {
1398                 efl_text_ellipsis_get_static_delegate = new efl_text_ellipsis_get_delegate(ellipsis_get);
1399             }
1400
1401             if (methods.FirstOrDefault(m => m.Name == "GetEllipsis") != null)
1402             {
1403                 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) });
1404             }
1405
1406             if (efl_text_ellipsis_set_static_delegate == null)
1407             {
1408                 efl_text_ellipsis_set_static_delegate = new efl_text_ellipsis_set_delegate(ellipsis_set);
1409             }
1410
1411             if (methods.FirstOrDefault(m => m.Name == "SetEllipsis") != null)
1412             {
1413                 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) });
1414             }
1415
1416             if (efl_text_wrap_get_static_delegate == null)
1417             {
1418                 efl_text_wrap_get_static_delegate = new efl_text_wrap_get_delegate(wrap_get);
1419             }
1420
1421             if (methods.FirstOrDefault(m => m.Name == "GetWrap") != null)
1422             {
1423                 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) });
1424             }
1425
1426             if (efl_text_wrap_set_static_delegate == null)
1427             {
1428                 efl_text_wrap_set_static_delegate = new efl_text_wrap_set_delegate(wrap_set);
1429             }
1430
1431             if (methods.FirstOrDefault(m => m.Name == "SetWrap") != null)
1432             {
1433                 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) });
1434             }
1435
1436             if (efl_text_multiline_get_static_delegate == null)
1437             {
1438                 efl_text_multiline_get_static_delegate = new efl_text_multiline_get_delegate(multiline_get);
1439             }
1440
1441             if (methods.FirstOrDefault(m => m.Name == "GetMultiline") != null)
1442             {
1443                 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) });
1444             }
1445
1446             if (efl_text_multiline_set_static_delegate == null)
1447             {
1448                 efl_text_multiline_set_static_delegate = new efl_text_multiline_set_delegate(multiline_set);
1449             }
1450
1451             if (methods.FirstOrDefault(m => m.Name == "SetMultiline") != null)
1452             {
1453                 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) });
1454             }
1455
1456             if (efl_text_halign_auto_type_get_static_delegate == null)
1457             {
1458                 efl_text_halign_auto_type_get_static_delegate = new efl_text_halign_auto_type_get_delegate(halign_auto_type_get);
1459             }
1460
1461             if (methods.FirstOrDefault(m => m.Name == "GetHalignAutoType") != null)
1462             {
1463                 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) });
1464             }
1465
1466             if (efl_text_halign_auto_type_set_static_delegate == null)
1467             {
1468                 efl_text_halign_auto_type_set_static_delegate = new efl_text_halign_auto_type_set_delegate(halign_auto_type_set);
1469             }
1470
1471             if (methods.FirstOrDefault(m => m.Name == "SetHalignAutoType") != null)
1472             {
1473                 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) });
1474             }
1475
1476             if (efl_text_halign_get_static_delegate == null)
1477             {
1478                 efl_text_halign_get_static_delegate = new efl_text_halign_get_delegate(halign_get);
1479             }
1480
1481             if (methods.FirstOrDefault(m => m.Name == "GetHalign") != null)
1482             {
1483                 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) });
1484             }
1485
1486             if (efl_text_halign_set_static_delegate == null)
1487             {
1488                 efl_text_halign_set_static_delegate = new efl_text_halign_set_delegate(halign_set);
1489             }
1490
1491             if (methods.FirstOrDefault(m => m.Name == "SetHalign") != null)
1492             {
1493                 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) });
1494             }
1495
1496             if (efl_text_valign_get_static_delegate == null)
1497             {
1498                 efl_text_valign_get_static_delegate = new efl_text_valign_get_delegate(valign_get);
1499             }
1500
1501             if (methods.FirstOrDefault(m => m.Name == "GetValign") != null)
1502             {
1503                 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) });
1504             }
1505
1506             if (efl_text_valign_set_static_delegate == null)
1507             {
1508                 efl_text_valign_set_static_delegate = new efl_text_valign_set_delegate(valign_set);
1509             }
1510
1511             if (methods.FirstOrDefault(m => m.Name == "SetValign") != null)
1512             {
1513                 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) });
1514             }
1515
1516             if (efl_text_linegap_get_static_delegate == null)
1517             {
1518                 efl_text_linegap_get_static_delegate = new efl_text_linegap_get_delegate(linegap_get);
1519             }
1520
1521             if (methods.FirstOrDefault(m => m.Name == "GetLinegap") != null)
1522             {
1523                 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) });
1524             }
1525
1526             if (efl_text_linegap_set_static_delegate == null)
1527             {
1528                 efl_text_linegap_set_static_delegate = new efl_text_linegap_set_delegate(linegap_set);
1529             }
1530
1531             if (methods.FirstOrDefault(m => m.Name == "SetLinegap") != null)
1532             {
1533                 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) });
1534             }
1535
1536             if (efl_text_linerelgap_get_static_delegate == null)
1537             {
1538                 efl_text_linerelgap_get_static_delegate = new efl_text_linerelgap_get_delegate(linerelgap_get);
1539             }
1540
1541             if (methods.FirstOrDefault(m => m.Name == "GetLinerelgap") != null)
1542             {
1543                 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) });
1544             }
1545
1546             if (efl_text_linerelgap_set_static_delegate == null)
1547             {
1548                 efl_text_linerelgap_set_static_delegate = new efl_text_linerelgap_set_delegate(linerelgap_set);
1549             }
1550
1551             if (methods.FirstOrDefault(m => m.Name == "SetLinerelgap") != null)
1552             {
1553                 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) });
1554             }
1555
1556             if (efl_text_tabstops_get_static_delegate == null)
1557             {
1558                 efl_text_tabstops_get_static_delegate = new efl_text_tabstops_get_delegate(tabstops_get);
1559             }
1560
1561             if (methods.FirstOrDefault(m => m.Name == "GetTabstops") != null)
1562             {
1563                 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) });
1564             }
1565
1566             if (efl_text_tabstops_set_static_delegate == null)
1567             {
1568                 efl_text_tabstops_set_static_delegate = new efl_text_tabstops_set_delegate(tabstops_set);
1569             }
1570
1571             if (methods.FirstOrDefault(m => m.Name == "SetTabstops") != null)
1572             {
1573                 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) });
1574             }
1575
1576             if (efl_text_password_get_static_delegate == null)
1577             {
1578                 efl_text_password_get_static_delegate = new efl_text_password_get_delegate(password_get);
1579             }
1580
1581             if (methods.FirstOrDefault(m => m.Name == "GetPassword") != null)
1582             {
1583                 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) });
1584             }
1585
1586             if (efl_text_password_set_static_delegate == null)
1587             {
1588                 efl_text_password_set_static_delegate = new efl_text_password_set_delegate(password_set);
1589             }
1590
1591             if (methods.FirstOrDefault(m => m.Name == "SetPassword") != null)
1592             {
1593                 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) });
1594             }
1595
1596             if (efl_text_replacement_char_get_static_delegate == null)
1597             {
1598                 efl_text_replacement_char_get_static_delegate = new efl_text_replacement_char_get_delegate(replacement_char_get);
1599             }
1600
1601             if (methods.FirstOrDefault(m => m.Name == "GetReplacementChar") != null)
1602             {
1603                 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) });
1604             }
1605
1606             if (efl_text_replacement_char_set_static_delegate == null)
1607             {
1608                 efl_text_replacement_char_set_static_delegate = new efl_text_replacement_char_set_delegate(replacement_char_set);
1609             }
1610
1611             if (methods.FirstOrDefault(m => m.Name == "SetReplacementChar") != null)
1612             {
1613                 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) });
1614             }
1615
1616             if (efl_text_normal_color_get_static_delegate == null)
1617             {
1618                 efl_text_normal_color_get_static_delegate = new efl_text_normal_color_get_delegate(normal_color_get);
1619             }
1620
1621             if (methods.FirstOrDefault(m => m.Name == "GetNormalColor") != null)
1622             {
1623                 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) });
1624             }
1625
1626             if (efl_text_normal_color_set_static_delegate == null)
1627             {
1628                 efl_text_normal_color_set_static_delegate = new efl_text_normal_color_set_delegate(normal_color_set);
1629             }
1630
1631             if (methods.FirstOrDefault(m => m.Name == "SetNormalColor") != null)
1632             {
1633                 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) });
1634             }
1635
1636             if (efl_text_backing_type_get_static_delegate == null)
1637             {
1638                 efl_text_backing_type_get_static_delegate = new efl_text_backing_type_get_delegate(backing_type_get);
1639             }
1640
1641             if (methods.FirstOrDefault(m => m.Name == "GetBackingType") != null)
1642             {
1643                 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) });
1644             }
1645
1646             if (efl_text_backing_type_set_static_delegate == null)
1647             {
1648                 efl_text_backing_type_set_static_delegate = new efl_text_backing_type_set_delegate(backing_type_set);
1649             }
1650
1651             if (methods.FirstOrDefault(m => m.Name == "SetBackingType") != null)
1652             {
1653                 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) });
1654             }
1655
1656             if (efl_text_backing_color_get_static_delegate == null)
1657             {
1658                 efl_text_backing_color_get_static_delegate = new efl_text_backing_color_get_delegate(backing_color_get);
1659             }
1660
1661             if (methods.FirstOrDefault(m => m.Name == "GetBackingColor") != null)
1662             {
1663                 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) });
1664             }
1665
1666             if (efl_text_backing_color_set_static_delegate == null)
1667             {
1668                 efl_text_backing_color_set_static_delegate = new efl_text_backing_color_set_delegate(backing_color_set);
1669             }
1670
1671             if (methods.FirstOrDefault(m => m.Name == "SetBackingColor") != null)
1672             {
1673                 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) });
1674             }
1675
1676             if (efl_text_underline_type_get_static_delegate == null)
1677             {
1678                 efl_text_underline_type_get_static_delegate = new efl_text_underline_type_get_delegate(underline_type_get);
1679             }
1680
1681             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineType") != null)
1682             {
1683                 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) });
1684             }
1685
1686             if (efl_text_underline_type_set_static_delegate == null)
1687             {
1688                 efl_text_underline_type_set_static_delegate = new efl_text_underline_type_set_delegate(underline_type_set);
1689             }
1690
1691             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineType") != null)
1692             {
1693                 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) });
1694             }
1695
1696             if (efl_text_underline_color_get_static_delegate == null)
1697             {
1698                 efl_text_underline_color_get_static_delegate = new efl_text_underline_color_get_delegate(underline_color_get);
1699             }
1700
1701             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineColor") != null)
1702             {
1703                 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) });
1704             }
1705
1706             if (efl_text_underline_color_set_static_delegate == null)
1707             {
1708                 efl_text_underline_color_set_static_delegate = new efl_text_underline_color_set_delegate(underline_color_set);
1709             }
1710
1711             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineColor") != null)
1712             {
1713                 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) });
1714             }
1715
1716             if (efl_text_underline_height_get_static_delegate == null)
1717             {
1718                 efl_text_underline_height_get_static_delegate = new efl_text_underline_height_get_delegate(underline_height_get);
1719             }
1720
1721             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineHeight") != null)
1722             {
1723                 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) });
1724             }
1725
1726             if (efl_text_underline_height_set_static_delegate == null)
1727             {
1728                 efl_text_underline_height_set_static_delegate = new efl_text_underline_height_set_delegate(underline_height_set);
1729             }
1730
1731             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineHeight") != null)
1732             {
1733                 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) });
1734             }
1735
1736             if (efl_text_underline_dashed_color_get_static_delegate == null)
1737             {
1738                 efl_text_underline_dashed_color_get_static_delegate = new efl_text_underline_dashed_color_get_delegate(underline_dashed_color_get);
1739             }
1740
1741             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedColor") != null)
1742             {
1743                 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) });
1744             }
1745
1746             if (efl_text_underline_dashed_color_set_static_delegate == null)
1747             {
1748                 efl_text_underline_dashed_color_set_static_delegate = new efl_text_underline_dashed_color_set_delegate(underline_dashed_color_set);
1749             }
1750
1751             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedColor") != null)
1752             {
1753                 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) });
1754             }
1755
1756             if (efl_text_underline_dashed_width_get_static_delegate == null)
1757             {
1758                 efl_text_underline_dashed_width_get_static_delegate = new efl_text_underline_dashed_width_get_delegate(underline_dashed_width_get);
1759             }
1760
1761             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedWidth") != null)
1762             {
1763                 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) });
1764             }
1765
1766             if (efl_text_underline_dashed_width_set_static_delegate == null)
1767             {
1768                 efl_text_underline_dashed_width_set_static_delegate = new efl_text_underline_dashed_width_set_delegate(underline_dashed_width_set);
1769             }
1770
1771             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedWidth") != null)
1772             {
1773                 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) });
1774             }
1775
1776             if (efl_text_underline_dashed_gap_get_static_delegate == null)
1777             {
1778                 efl_text_underline_dashed_gap_get_static_delegate = new efl_text_underline_dashed_gap_get_delegate(underline_dashed_gap_get);
1779             }
1780
1781             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedGap") != null)
1782             {
1783                 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) });
1784             }
1785
1786             if (efl_text_underline_dashed_gap_set_static_delegate == null)
1787             {
1788                 efl_text_underline_dashed_gap_set_static_delegate = new efl_text_underline_dashed_gap_set_delegate(underline_dashed_gap_set);
1789             }
1790
1791             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedGap") != null)
1792             {
1793                 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) });
1794             }
1795
1796             if (efl_text_underline2_color_get_static_delegate == null)
1797             {
1798                 efl_text_underline2_color_get_static_delegate = new efl_text_underline2_color_get_delegate(underline2_color_get);
1799             }
1800
1801             if (methods.FirstOrDefault(m => m.Name == "GetUnderline2Color") != null)
1802             {
1803                 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) });
1804             }
1805
1806             if (efl_text_underline2_color_set_static_delegate == null)
1807             {
1808                 efl_text_underline2_color_set_static_delegate = new efl_text_underline2_color_set_delegate(underline2_color_set);
1809             }
1810
1811             if (methods.FirstOrDefault(m => m.Name == "SetUnderline2Color") != null)
1812             {
1813                 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) });
1814             }
1815
1816             if (efl_text_strikethrough_type_get_static_delegate == null)
1817             {
1818                 efl_text_strikethrough_type_get_static_delegate = new efl_text_strikethrough_type_get_delegate(strikethrough_type_get);
1819             }
1820
1821             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughType") != null)
1822             {
1823                 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) });
1824             }
1825
1826             if (efl_text_strikethrough_type_set_static_delegate == null)
1827             {
1828                 efl_text_strikethrough_type_set_static_delegate = new efl_text_strikethrough_type_set_delegate(strikethrough_type_set);
1829             }
1830
1831             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughType") != null)
1832             {
1833                 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) });
1834             }
1835
1836             if (efl_text_strikethrough_color_get_static_delegate == null)
1837             {
1838                 efl_text_strikethrough_color_get_static_delegate = new efl_text_strikethrough_color_get_delegate(strikethrough_color_get);
1839             }
1840
1841             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughColor") != null)
1842             {
1843                 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) });
1844             }
1845
1846             if (efl_text_strikethrough_color_set_static_delegate == null)
1847             {
1848                 efl_text_strikethrough_color_set_static_delegate = new efl_text_strikethrough_color_set_delegate(strikethrough_color_set);
1849             }
1850
1851             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughColor") != null)
1852             {
1853                 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) });
1854             }
1855
1856             if (efl_text_effect_type_get_static_delegate == null)
1857             {
1858                 efl_text_effect_type_get_static_delegate = new efl_text_effect_type_get_delegate(effect_type_get);
1859             }
1860
1861             if (methods.FirstOrDefault(m => m.Name == "GetEffectType") != null)
1862             {
1863                 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) });
1864             }
1865
1866             if (efl_text_effect_type_set_static_delegate == null)
1867             {
1868                 efl_text_effect_type_set_static_delegate = new efl_text_effect_type_set_delegate(effect_type_set);
1869             }
1870
1871             if (methods.FirstOrDefault(m => m.Name == "SetEffectType") != null)
1872             {
1873                 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) });
1874             }
1875
1876             if (efl_text_outline_color_get_static_delegate == null)
1877             {
1878                 efl_text_outline_color_get_static_delegate = new efl_text_outline_color_get_delegate(outline_color_get);
1879             }
1880
1881             if (methods.FirstOrDefault(m => m.Name == "GetOutlineColor") != null)
1882             {
1883                 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) });
1884             }
1885
1886             if (efl_text_outline_color_set_static_delegate == null)
1887             {
1888                 efl_text_outline_color_set_static_delegate = new efl_text_outline_color_set_delegate(outline_color_set);
1889             }
1890
1891             if (methods.FirstOrDefault(m => m.Name == "SetOutlineColor") != null)
1892             {
1893                 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) });
1894             }
1895
1896             if (efl_text_shadow_direction_get_static_delegate == null)
1897             {
1898                 efl_text_shadow_direction_get_static_delegate = new efl_text_shadow_direction_get_delegate(shadow_direction_get);
1899             }
1900
1901             if (methods.FirstOrDefault(m => m.Name == "GetShadowDirection") != null)
1902             {
1903                 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) });
1904             }
1905
1906             if (efl_text_shadow_direction_set_static_delegate == null)
1907             {
1908                 efl_text_shadow_direction_set_static_delegate = new efl_text_shadow_direction_set_delegate(shadow_direction_set);
1909             }
1910
1911             if (methods.FirstOrDefault(m => m.Name == "SetShadowDirection") != null)
1912             {
1913                 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) });
1914             }
1915
1916             if (efl_text_shadow_color_get_static_delegate == null)
1917             {
1918                 efl_text_shadow_color_get_static_delegate = new efl_text_shadow_color_get_delegate(shadow_color_get);
1919             }
1920
1921             if (methods.FirstOrDefault(m => m.Name == "GetShadowColor") != null)
1922             {
1923                 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) });
1924             }
1925
1926             if (efl_text_shadow_color_set_static_delegate == null)
1927             {
1928                 efl_text_shadow_color_set_static_delegate = new efl_text_shadow_color_set_delegate(shadow_color_set);
1929             }
1930
1931             if (methods.FirstOrDefault(m => m.Name == "SetShadowColor") != null)
1932             {
1933                 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) });
1934             }
1935
1936             if (efl_text_glow_color_get_static_delegate == null)
1937             {
1938                 efl_text_glow_color_get_static_delegate = new efl_text_glow_color_get_delegate(glow_color_get);
1939             }
1940
1941             if (methods.FirstOrDefault(m => m.Name == "GetGlowColor") != null)
1942             {
1943                 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) });
1944             }
1945
1946             if (efl_text_glow_color_set_static_delegate == null)
1947             {
1948                 efl_text_glow_color_set_static_delegate = new efl_text_glow_color_set_delegate(glow_color_set);
1949             }
1950
1951             if (methods.FirstOrDefault(m => m.Name == "SetGlowColor") != null)
1952             {
1953                 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) });
1954             }
1955
1956             if (efl_text_glow2_color_get_static_delegate == null)
1957             {
1958                 efl_text_glow2_color_get_static_delegate = new efl_text_glow2_color_get_delegate(glow2_color_get);
1959             }
1960
1961             if (methods.FirstOrDefault(m => m.Name == "GetGlow2Color") != null)
1962             {
1963                 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) });
1964             }
1965
1966             if (efl_text_glow2_color_set_static_delegate == null)
1967             {
1968                 efl_text_glow2_color_set_static_delegate = new efl_text_glow2_color_set_delegate(glow2_color_set);
1969             }
1970
1971             if (methods.FirstOrDefault(m => m.Name == "SetGlow2Color") != null)
1972             {
1973                 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) });
1974             }
1975
1976             if (efl_text_gfx_filter_get_static_delegate == null)
1977             {
1978                 efl_text_gfx_filter_get_static_delegate = new efl_text_gfx_filter_get_delegate(gfx_filter_get);
1979             }
1980
1981             if (methods.FirstOrDefault(m => m.Name == "GetGfxFilter") != null)
1982             {
1983                 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) });
1984             }
1985
1986             if (efl_text_gfx_filter_set_static_delegate == null)
1987             {
1988                 efl_text_gfx_filter_set_static_delegate = new efl_text_gfx_filter_set_delegate(gfx_filter_set);
1989             }
1990
1991             if (methods.FirstOrDefault(m => m.Name == "SetGfxFilter") != null)
1992             {
1993                 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) });
1994             }
1995
1996             return descs;
1997         }
1998         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1999         /// <returns>The native class pointer.</returns>
2000         public override IntPtr GetEflClass()
2001         {
2002             return Efl.ITextInteractiveConcrete.efl_text_interactive_interface_get();
2003         }
2004
2005         #pragma warning disable CA1707, CS1591, SA1300, SA1600
2006
2007         [return: MarshalAs(UnmanagedType.U1)]
2008         private delegate bool efl_text_interactive_selection_allowed_get_delegate(System.IntPtr obj, System.IntPtr pd);
2009
2010         [return: MarshalAs(UnmanagedType.U1)]
2011         public delegate bool efl_text_interactive_selection_allowed_get_api_delegate(System.IntPtr obj);
2012
2013         public static Efl.Eo.FunctionWrapper<efl_text_interactive_selection_allowed_get_api_delegate> efl_text_interactive_selection_allowed_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_selection_allowed_get_api_delegate>(Module, "efl_text_interactive_selection_allowed_get");
2014
2015         private static bool selection_allowed_get(System.IntPtr obj, System.IntPtr pd)
2016         {
2017             Eina.Log.Debug("function efl_text_interactive_selection_allowed_get was called");
2018             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2019             if (ws != null)
2020             {
2021             bool _ret_var = default(bool);
2022                 try
2023                 {
2024                     _ret_var = ((ITextInteractive)ws.Target).GetSelectionAllowed();
2025                 }
2026                 catch (Exception e)
2027                 {
2028                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2029                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2030                 }
2031
2032         return _ret_var;
2033
2034             }
2035             else
2036             {
2037                 return efl_text_interactive_selection_allowed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2038             }
2039         }
2040
2041         private static efl_text_interactive_selection_allowed_get_delegate efl_text_interactive_selection_allowed_get_static_delegate;
2042
2043
2044         private delegate void efl_text_interactive_selection_allowed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool allowed);
2045
2046
2047         public delegate void efl_text_interactive_selection_allowed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool allowed);
2048
2049         public static Efl.Eo.FunctionWrapper<efl_text_interactive_selection_allowed_set_api_delegate> efl_text_interactive_selection_allowed_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_selection_allowed_set_api_delegate>(Module, "efl_text_interactive_selection_allowed_set");
2050
2051         private static void selection_allowed_set(System.IntPtr obj, System.IntPtr pd, bool allowed)
2052         {
2053             Eina.Log.Debug("function efl_text_interactive_selection_allowed_set was called");
2054             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2055             if (ws != null)
2056             {
2057
2058                 try
2059                 {
2060                     ((ITextInteractive)ws.Target).SetSelectionAllowed(allowed);
2061                 }
2062                 catch (Exception e)
2063                 {
2064                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2065                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2066                 }
2067
2068
2069             }
2070             else
2071             {
2072                 efl_text_interactive_selection_allowed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), allowed);
2073             }
2074         }
2075
2076         private static efl_text_interactive_selection_allowed_set_delegate efl_text_interactive_selection_allowed_set_static_delegate;
2077
2078
2079         private delegate void efl_text_interactive_selection_cursors_get_delegate(System.IntPtr obj, System.IntPtr pd,  out Efl.TextCursorCursor start,  out Efl.TextCursorCursor end);
2080
2081
2082         public delegate void efl_text_interactive_selection_cursors_get_api_delegate(System.IntPtr obj,  out Efl.TextCursorCursor start,  out Efl.TextCursorCursor end);
2083
2084         public static Efl.Eo.FunctionWrapper<efl_text_interactive_selection_cursors_get_api_delegate> efl_text_interactive_selection_cursors_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_selection_cursors_get_api_delegate>(Module, "efl_text_interactive_selection_cursors_get");
2085
2086         private static void selection_cursors_get(System.IntPtr obj, System.IntPtr pd, out Efl.TextCursorCursor start, out Efl.TextCursorCursor end)
2087         {
2088             Eina.Log.Debug("function efl_text_interactive_selection_cursors_get was called");
2089             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2090             if (ws != null)
2091             {
2092                         start = default(Efl.TextCursorCursor);        end = default(Efl.TextCursorCursor);
2093                 try
2094                 {
2095                     ((ITextInteractive)ws.Target).GetSelectionCursors(out start, out end);
2096                 }
2097                 catch (Exception e)
2098                 {
2099                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2100                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2101                 }
2102
2103
2104             }
2105             else
2106             {
2107                 efl_text_interactive_selection_cursors_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out start, out end);
2108             }
2109         }
2110
2111         private static efl_text_interactive_selection_cursors_get_delegate efl_text_interactive_selection_cursors_get_static_delegate;
2112
2113         [return: MarshalAs(UnmanagedType.U1)]
2114         private delegate bool efl_text_interactive_editable_get_delegate(System.IntPtr obj, System.IntPtr pd);
2115
2116         [return: MarshalAs(UnmanagedType.U1)]
2117         public delegate bool efl_text_interactive_editable_get_api_delegate(System.IntPtr obj);
2118
2119         public static Efl.Eo.FunctionWrapper<efl_text_interactive_editable_get_api_delegate> efl_text_interactive_editable_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_editable_get_api_delegate>(Module, "efl_text_interactive_editable_get");
2120
2121         private static bool editable_get(System.IntPtr obj, System.IntPtr pd)
2122         {
2123             Eina.Log.Debug("function efl_text_interactive_editable_get was called");
2124             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2125             if (ws != null)
2126             {
2127             bool _ret_var = default(bool);
2128                 try
2129                 {
2130                     _ret_var = ((ITextInteractive)ws.Target).GetEditable();
2131                 }
2132                 catch (Exception e)
2133                 {
2134                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2135                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2136                 }
2137
2138         return _ret_var;
2139
2140             }
2141             else
2142             {
2143                 return efl_text_interactive_editable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2144             }
2145         }
2146
2147         private static efl_text_interactive_editable_get_delegate efl_text_interactive_editable_get_static_delegate;
2148
2149
2150         private delegate void efl_text_interactive_editable_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool editable);
2151
2152
2153         public delegate void efl_text_interactive_editable_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool editable);
2154
2155         public static Efl.Eo.FunctionWrapper<efl_text_interactive_editable_set_api_delegate> efl_text_interactive_editable_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_editable_set_api_delegate>(Module, "efl_text_interactive_editable_set");
2156
2157         private static void editable_set(System.IntPtr obj, System.IntPtr pd, bool editable)
2158         {
2159             Eina.Log.Debug("function efl_text_interactive_editable_set was called");
2160             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2161             if (ws != null)
2162             {
2163
2164                 try
2165                 {
2166                     ((ITextInteractive)ws.Target).SetEditable(editable);
2167                 }
2168                 catch (Exception e)
2169                 {
2170                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2171                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2172                 }
2173
2174
2175             }
2176             else
2177             {
2178                 efl_text_interactive_editable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), editable);
2179             }
2180         }
2181
2182         private static efl_text_interactive_editable_set_delegate efl_text_interactive_editable_set_static_delegate;
2183
2184
2185         private delegate void efl_text_interactive_select_none_delegate(System.IntPtr obj, System.IntPtr pd);
2186
2187
2188         public delegate void efl_text_interactive_select_none_api_delegate(System.IntPtr obj);
2189
2190         public static Efl.Eo.FunctionWrapper<efl_text_interactive_select_none_api_delegate> efl_text_interactive_select_none_ptr = new Efl.Eo.FunctionWrapper<efl_text_interactive_select_none_api_delegate>(Module, "efl_text_interactive_select_none");
2191
2192         private static void select_none(System.IntPtr obj, System.IntPtr pd)
2193         {
2194             Eina.Log.Debug("function efl_text_interactive_select_none was called");
2195             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2196             if (ws != null)
2197             {
2198
2199                 try
2200                 {
2201                     ((ITextInteractive)ws.Target).SelectNone();
2202                 }
2203                 catch (Exception e)
2204                 {
2205                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2206                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2207                 }
2208
2209
2210             }
2211             else
2212             {
2213                 efl_text_interactive_select_none_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2214             }
2215         }
2216
2217         private static efl_text_interactive_select_none_delegate efl_text_interactive_select_none_static_delegate;
2218
2219         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2220         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
2221
2222         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2223         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
2224
2225         public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
2226
2227         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
2228         {
2229             Eina.Log.Debug("function efl_text_get was called");
2230             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2231             if (ws != null)
2232             {
2233             System.String _ret_var = default(System.String);
2234                 try
2235                 {
2236                     _ret_var = ((ITextInteractive)ws.Target).GetText();
2237                 }
2238                 catch (Exception e)
2239                 {
2240                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2241                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2242                 }
2243
2244         return _ret_var;
2245
2246             }
2247             else
2248             {
2249                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2250             }
2251         }
2252
2253         private static efl_text_get_delegate efl_text_get_static_delegate;
2254
2255
2256         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2257
2258
2259         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2260
2261         public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
2262
2263         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
2264         {
2265             Eina.Log.Debug("function efl_text_set was called");
2266             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2267             if (ws != null)
2268             {
2269
2270                 try
2271                 {
2272                     ((ITextInteractive)ws.Target).SetText(text);
2273                 }
2274                 catch (Exception e)
2275                 {
2276                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2277                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2278                 }
2279
2280
2281             }
2282             else
2283             {
2284                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
2285             }
2286         }
2287
2288         private static efl_text_set_delegate efl_text_set_static_delegate;
2289
2290
2291         private delegate void efl_text_font_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String font,  out Efl.Font.Size size);
2292
2293
2294         public delegate void efl_text_font_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String font,  out Efl.Font.Size size);
2295
2296         public static Efl.Eo.FunctionWrapper<efl_text_font_get_api_delegate> efl_text_font_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_get_api_delegate>(Module, "efl_text_font_get");
2297
2298         private static void font_get(System.IntPtr obj, System.IntPtr pd, out System.String font, out Efl.Font.Size size)
2299         {
2300             Eina.Log.Debug("function efl_text_font_get was called");
2301             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2302             if (ws != null)
2303             {
2304                         System.String _out_font = default(System.String);
2305         size = default(Efl.Font.Size);
2306                 try
2307                 {
2308                     ((ITextInteractive)ws.Target).GetFont(out _out_font, out size);
2309                 }
2310                 catch (Exception e)
2311                 {
2312                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2313                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2314                 }
2315
2316         font = _out_font;
2317
2318             }
2319             else
2320             {
2321                 efl_text_font_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out font, out size);
2322             }
2323         }
2324
2325         private static efl_text_font_get_delegate efl_text_font_get_static_delegate;
2326
2327
2328         private delegate void efl_text_font_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font,  Efl.Font.Size size);
2329
2330
2331         public delegate void efl_text_font_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font,  Efl.Font.Size size);
2332
2333         public static Efl.Eo.FunctionWrapper<efl_text_font_set_api_delegate> efl_text_font_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_set_api_delegate>(Module, "efl_text_font_set");
2334
2335         private static void font_set(System.IntPtr obj, System.IntPtr pd, System.String font, Efl.Font.Size size)
2336         {
2337             Eina.Log.Debug("function efl_text_font_set was called");
2338             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2339             if (ws != null)
2340             {
2341
2342                 try
2343                 {
2344                     ((ITextInteractive)ws.Target).SetFont(font, size);
2345                 }
2346                 catch (Exception e)
2347                 {
2348                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2349                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2350                 }
2351
2352
2353             }
2354             else
2355             {
2356                 efl_text_font_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font, size);
2357             }
2358         }
2359
2360         private static efl_text_font_set_delegate efl_text_font_set_static_delegate;
2361
2362         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2363         private delegate System.String efl_text_font_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
2364
2365         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2366         public delegate System.String efl_text_font_source_get_api_delegate(System.IntPtr obj);
2367
2368         public static Efl.Eo.FunctionWrapper<efl_text_font_source_get_api_delegate> efl_text_font_source_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_source_get_api_delegate>(Module, "efl_text_font_source_get");
2369
2370         private static System.String font_source_get(System.IntPtr obj, System.IntPtr pd)
2371         {
2372             Eina.Log.Debug("function efl_text_font_source_get was called");
2373             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2374             if (ws != null)
2375             {
2376             System.String _ret_var = default(System.String);
2377                 try
2378                 {
2379                     _ret_var = ((ITextInteractive)ws.Target).GetFontSource();
2380                 }
2381                 catch (Exception e)
2382                 {
2383                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2384                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2385                 }
2386
2387         return _ret_var;
2388
2389             }
2390             else
2391             {
2392                 return efl_text_font_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2393             }
2394         }
2395
2396         private static efl_text_font_source_get_delegate efl_text_font_source_get_static_delegate;
2397
2398
2399         private delegate void efl_text_font_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_source);
2400
2401
2402         public delegate void efl_text_font_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_source);
2403
2404         public static Efl.Eo.FunctionWrapper<efl_text_font_source_set_api_delegate> efl_text_font_source_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_source_set_api_delegate>(Module, "efl_text_font_source_set");
2405
2406         private static void font_source_set(System.IntPtr obj, System.IntPtr pd, System.String font_source)
2407         {
2408             Eina.Log.Debug("function efl_text_font_source_set was called");
2409             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2410             if (ws != null)
2411             {
2412
2413                 try
2414                 {
2415                     ((ITextInteractive)ws.Target).SetFontSource(font_source);
2416                 }
2417                 catch (Exception e)
2418                 {
2419                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2420                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2421                 }
2422
2423
2424             }
2425             else
2426             {
2427                 efl_text_font_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_source);
2428             }
2429         }
2430
2431         private static efl_text_font_source_set_delegate efl_text_font_source_set_static_delegate;
2432
2433         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2434         private delegate System.String efl_text_font_fallbacks_get_delegate(System.IntPtr obj, System.IntPtr pd);
2435
2436         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2437         public delegate System.String efl_text_font_fallbacks_get_api_delegate(System.IntPtr obj);
2438
2439         public static Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_get_api_delegate> efl_text_font_fallbacks_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_get_api_delegate>(Module, "efl_text_font_fallbacks_get");
2440
2441         private static System.String font_fallbacks_get(System.IntPtr obj, System.IntPtr pd)
2442         {
2443             Eina.Log.Debug("function efl_text_font_fallbacks_get was called");
2444             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2445             if (ws != null)
2446             {
2447             System.String _ret_var = default(System.String);
2448                 try
2449                 {
2450                     _ret_var = ((ITextInteractive)ws.Target).GetFontFallbacks();
2451                 }
2452                 catch (Exception e)
2453                 {
2454                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2455                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2456                 }
2457
2458         return _ret_var;
2459
2460             }
2461             else
2462             {
2463                 return efl_text_font_fallbacks_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2464             }
2465         }
2466
2467         private static efl_text_font_fallbacks_get_delegate efl_text_font_fallbacks_get_static_delegate;
2468
2469
2470         private delegate void efl_text_font_fallbacks_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_fallbacks);
2471
2472
2473         public delegate void efl_text_font_fallbacks_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String font_fallbacks);
2474
2475         public static Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_set_api_delegate> efl_text_font_fallbacks_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_fallbacks_set_api_delegate>(Module, "efl_text_font_fallbacks_set");
2476
2477         private static void font_fallbacks_set(System.IntPtr obj, System.IntPtr pd, System.String font_fallbacks)
2478         {
2479             Eina.Log.Debug("function efl_text_font_fallbacks_set was called");
2480             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2481             if (ws != null)
2482             {
2483
2484                 try
2485                 {
2486                     ((ITextInteractive)ws.Target).SetFontFallbacks(font_fallbacks);
2487                 }
2488                 catch (Exception e)
2489                 {
2490                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2491                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2492                 }
2493
2494
2495             }
2496             else
2497             {
2498                 efl_text_font_fallbacks_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_fallbacks);
2499             }
2500         }
2501
2502         private static efl_text_font_fallbacks_set_delegate efl_text_font_fallbacks_set_static_delegate;
2503
2504
2505         private delegate Efl.TextFontWeight efl_text_font_weight_get_delegate(System.IntPtr obj, System.IntPtr pd);
2506
2507
2508         public delegate Efl.TextFontWeight efl_text_font_weight_get_api_delegate(System.IntPtr obj);
2509
2510         public static Efl.Eo.FunctionWrapper<efl_text_font_weight_get_api_delegate> efl_text_font_weight_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_weight_get_api_delegate>(Module, "efl_text_font_weight_get");
2511
2512         private static Efl.TextFontWeight font_weight_get(System.IntPtr obj, System.IntPtr pd)
2513         {
2514             Eina.Log.Debug("function efl_text_font_weight_get was called");
2515             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2516             if (ws != null)
2517             {
2518             Efl.TextFontWeight _ret_var = default(Efl.TextFontWeight);
2519                 try
2520                 {
2521                     _ret_var = ((ITextInteractive)ws.Target).GetFontWeight();
2522                 }
2523                 catch (Exception e)
2524                 {
2525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2527                 }
2528
2529         return _ret_var;
2530
2531             }
2532             else
2533             {
2534                 return efl_text_font_weight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2535             }
2536         }
2537
2538         private static efl_text_font_weight_get_delegate efl_text_font_weight_get_static_delegate;
2539
2540
2541         private delegate void efl_text_font_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWeight font_weight);
2542
2543
2544         public delegate void efl_text_font_weight_set_api_delegate(System.IntPtr obj,  Efl.TextFontWeight font_weight);
2545
2546         public static Efl.Eo.FunctionWrapper<efl_text_font_weight_set_api_delegate> efl_text_font_weight_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_weight_set_api_delegate>(Module, "efl_text_font_weight_set");
2547
2548         private static void font_weight_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWeight font_weight)
2549         {
2550             Eina.Log.Debug("function efl_text_font_weight_set was called");
2551             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2552             if (ws != null)
2553             {
2554
2555                 try
2556                 {
2557                     ((ITextInteractive)ws.Target).SetFontWeight(font_weight);
2558                 }
2559                 catch (Exception e)
2560                 {
2561                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2562                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2563                 }
2564
2565
2566             }
2567             else
2568             {
2569                 efl_text_font_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_weight);
2570             }
2571         }
2572
2573         private static efl_text_font_weight_set_delegate efl_text_font_weight_set_static_delegate;
2574
2575
2576         private delegate Efl.TextFontSlant efl_text_font_slant_get_delegate(System.IntPtr obj, System.IntPtr pd);
2577
2578
2579         public delegate Efl.TextFontSlant efl_text_font_slant_get_api_delegate(System.IntPtr obj);
2580
2581         public static Efl.Eo.FunctionWrapper<efl_text_font_slant_get_api_delegate> efl_text_font_slant_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_slant_get_api_delegate>(Module, "efl_text_font_slant_get");
2582
2583         private static Efl.TextFontSlant font_slant_get(System.IntPtr obj, System.IntPtr pd)
2584         {
2585             Eina.Log.Debug("function efl_text_font_slant_get was called");
2586             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2587             if (ws != null)
2588             {
2589             Efl.TextFontSlant _ret_var = default(Efl.TextFontSlant);
2590                 try
2591                 {
2592                     _ret_var = ((ITextInteractive)ws.Target).GetFontSlant();
2593                 }
2594                 catch (Exception e)
2595                 {
2596                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2597                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2598                 }
2599
2600         return _ret_var;
2601
2602             }
2603             else
2604             {
2605                 return efl_text_font_slant_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2606             }
2607         }
2608
2609         private static efl_text_font_slant_get_delegate efl_text_font_slant_get_static_delegate;
2610
2611
2612         private delegate void efl_text_font_slant_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontSlant style);
2613
2614
2615         public delegate void efl_text_font_slant_set_api_delegate(System.IntPtr obj,  Efl.TextFontSlant style);
2616
2617         public static Efl.Eo.FunctionWrapper<efl_text_font_slant_set_api_delegate> efl_text_font_slant_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_slant_set_api_delegate>(Module, "efl_text_font_slant_set");
2618
2619         private static void font_slant_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontSlant style)
2620         {
2621             Eina.Log.Debug("function efl_text_font_slant_set was called");
2622             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2623             if (ws != null)
2624             {
2625
2626                 try
2627                 {
2628                     ((ITextInteractive)ws.Target).SetFontSlant(style);
2629                 }
2630                 catch (Exception e)
2631                 {
2632                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2633                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2634                 }
2635
2636
2637             }
2638             else
2639             {
2640                 efl_text_font_slant_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), style);
2641             }
2642         }
2643
2644         private static efl_text_font_slant_set_delegate efl_text_font_slant_set_static_delegate;
2645
2646
2647         private delegate Efl.TextFontWidth efl_text_font_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
2648
2649
2650         public delegate Efl.TextFontWidth efl_text_font_width_get_api_delegate(System.IntPtr obj);
2651
2652         public static Efl.Eo.FunctionWrapper<efl_text_font_width_get_api_delegate> efl_text_font_width_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_width_get_api_delegate>(Module, "efl_text_font_width_get");
2653
2654         private static Efl.TextFontWidth font_width_get(System.IntPtr obj, System.IntPtr pd)
2655         {
2656             Eina.Log.Debug("function efl_text_font_width_get was called");
2657             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2658             if (ws != null)
2659             {
2660             Efl.TextFontWidth _ret_var = default(Efl.TextFontWidth);
2661                 try
2662                 {
2663                     _ret_var = ((ITextInteractive)ws.Target).GetFontWidth();
2664                 }
2665                 catch (Exception e)
2666                 {
2667                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2668                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2669                 }
2670
2671         return _ret_var;
2672
2673             }
2674             else
2675             {
2676                 return efl_text_font_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2677             }
2678         }
2679
2680         private static efl_text_font_width_get_delegate efl_text_font_width_get_static_delegate;
2681
2682
2683         private delegate void efl_text_font_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWidth width);
2684
2685
2686         public delegate void efl_text_font_width_set_api_delegate(System.IntPtr obj,  Efl.TextFontWidth width);
2687
2688         public static Efl.Eo.FunctionWrapper<efl_text_font_width_set_api_delegate> efl_text_font_width_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_width_set_api_delegate>(Module, "efl_text_font_width_set");
2689
2690         private static void font_width_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWidth width)
2691         {
2692             Eina.Log.Debug("function efl_text_font_width_set was called");
2693             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2694             if (ws != null)
2695             {
2696
2697                 try
2698                 {
2699                     ((ITextInteractive)ws.Target).SetFontWidth(width);
2700                 }
2701                 catch (Exception e)
2702                 {
2703                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2704                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2705                 }
2706
2707
2708             }
2709             else
2710             {
2711                 efl_text_font_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
2712             }
2713         }
2714
2715         private static efl_text_font_width_set_delegate efl_text_font_width_set_static_delegate;
2716
2717         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2718         private delegate System.String efl_text_font_lang_get_delegate(System.IntPtr obj, System.IntPtr pd);
2719
2720         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2721         public delegate System.String efl_text_font_lang_get_api_delegate(System.IntPtr obj);
2722
2723         public static Efl.Eo.FunctionWrapper<efl_text_font_lang_get_api_delegate> efl_text_font_lang_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_lang_get_api_delegate>(Module, "efl_text_font_lang_get");
2724
2725         private static System.String font_lang_get(System.IntPtr obj, System.IntPtr pd)
2726         {
2727             Eina.Log.Debug("function efl_text_font_lang_get was called");
2728             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2729             if (ws != null)
2730             {
2731             System.String _ret_var = default(System.String);
2732                 try
2733                 {
2734                     _ret_var = ((ITextInteractive)ws.Target).GetFontLang();
2735                 }
2736                 catch (Exception e)
2737                 {
2738                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2739                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2740                 }
2741
2742         return _ret_var;
2743
2744             }
2745             else
2746             {
2747                 return efl_text_font_lang_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2748             }
2749         }
2750
2751         private static efl_text_font_lang_get_delegate efl_text_font_lang_get_static_delegate;
2752
2753
2754         private delegate void efl_text_font_lang_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String lang);
2755
2756
2757         public delegate void efl_text_font_lang_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String lang);
2758
2759         public static Efl.Eo.FunctionWrapper<efl_text_font_lang_set_api_delegate> efl_text_font_lang_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_lang_set_api_delegate>(Module, "efl_text_font_lang_set");
2760
2761         private static void font_lang_set(System.IntPtr obj, System.IntPtr pd, System.String lang)
2762         {
2763             Eina.Log.Debug("function efl_text_font_lang_set was called");
2764             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2765             if (ws != null)
2766             {
2767
2768                 try
2769                 {
2770                     ((ITextInteractive)ws.Target).SetFontLang(lang);
2771                 }
2772                 catch (Exception e)
2773                 {
2774                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2775                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2776                 }
2777
2778
2779             }
2780             else
2781             {
2782                 efl_text_font_lang_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), lang);
2783             }
2784         }
2785
2786         private static efl_text_font_lang_set_delegate efl_text_font_lang_set_static_delegate;
2787
2788
2789         private delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_delegate(System.IntPtr obj, System.IntPtr pd);
2790
2791
2792         public delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_api_delegate(System.IntPtr obj);
2793
2794         public static Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_get_api_delegate> efl_text_font_bitmap_scalable_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_get_api_delegate>(Module, "efl_text_font_bitmap_scalable_get");
2795
2796         private static Efl.TextFontBitmapScalable font_bitmap_scalable_get(System.IntPtr obj, System.IntPtr pd)
2797         {
2798             Eina.Log.Debug("function efl_text_font_bitmap_scalable_get was called");
2799             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2800             if (ws != null)
2801             {
2802             Efl.TextFontBitmapScalable _ret_var = default(Efl.TextFontBitmapScalable);
2803                 try
2804                 {
2805                     _ret_var = ((ITextInteractive)ws.Target).GetFontBitmapScalable();
2806                 }
2807                 catch (Exception e)
2808                 {
2809                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2810                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2811                 }
2812
2813         return _ret_var;
2814
2815             }
2816             else
2817             {
2818                 return efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2819             }
2820         }
2821
2822         private static efl_text_font_bitmap_scalable_get_delegate efl_text_font_bitmap_scalable_get_static_delegate;
2823
2824
2825         private delegate void efl_text_font_bitmap_scalable_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontBitmapScalable scalable);
2826
2827
2828         public delegate void efl_text_font_bitmap_scalable_set_api_delegate(System.IntPtr obj,  Efl.TextFontBitmapScalable scalable);
2829
2830         public static Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_set_api_delegate> efl_text_font_bitmap_scalable_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_font_bitmap_scalable_set_api_delegate>(Module, "efl_text_font_bitmap_scalable_set");
2831
2832         private static void font_bitmap_scalable_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontBitmapScalable scalable)
2833         {
2834             Eina.Log.Debug("function efl_text_font_bitmap_scalable_set was called");
2835             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2836             if (ws != null)
2837             {
2838
2839                 try
2840                 {
2841                     ((ITextInteractive)ws.Target).SetFontBitmapScalable(scalable);
2842                 }
2843                 catch (Exception e)
2844                 {
2845                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2846                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2847                 }
2848
2849
2850             }
2851             else
2852             {
2853                 efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scalable);
2854             }
2855         }
2856
2857         private static efl_text_font_bitmap_scalable_set_delegate efl_text_font_bitmap_scalable_set_static_delegate;
2858
2859
2860         private delegate double efl_text_ellipsis_get_delegate(System.IntPtr obj, System.IntPtr pd);
2861
2862
2863         public delegate double efl_text_ellipsis_get_api_delegate(System.IntPtr obj);
2864
2865         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");
2866
2867         private static double ellipsis_get(System.IntPtr obj, System.IntPtr pd)
2868         {
2869             Eina.Log.Debug("function efl_text_ellipsis_get was called");
2870             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2871             if (ws != null)
2872             {
2873             double _ret_var = default(double);
2874                 try
2875                 {
2876                     _ret_var = ((ITextInteractive)ws.Target).GetEllipsis();
2877                 }
2878                 catch (Exception e)
2879                 {
2880                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2881                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2882                 }
2883
2884         return _ret_var;
2885
2886             }
2887             else
2888             {
2889                 return efl_text_ellipsis_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2890             }
2891         }
2892
2893         private static efl_text_ellipsis_get_delegate efl_text_ellipsis_get_static_delegate;
2894
2895
2896         private delegate void efl_text_ellipsis_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
2897
2898
2899         public delegate void efl_text_ellipsis_set_api_delegate(System.IntPtr obj,  double value);
2900
2901         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");
2902
2903         private static void ellipsis_set(System.IntPtr obj, System.IntPtr pd, double value)
2904         {
2905             Eina.Log.Debug("function efl_text_ellipsis_set was called");
2906             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2907             if (ws != null)
2908             {
2909
2910                 try
2911                 {
2912                     ((ITextInteractive)ws.Target).SetEllipsis(value);
2913                 }
2914                 catch (Exception e)
2915                 {
2916                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2917                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2918                 }
2919
2920
2921             }
2922             else
2923             {
2924                 efl_text_ellipsis_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
2925             }
2926         }
2927
2928         private static efl_text_ellipsis_set_delegate efl_text_ellipsis_set_static_delegate;
2929
2930
2931         private delegate Efl.TextFormatWrap efl_text_wrap_get_delegate(System.IntPtr obj, System.IntPtr pd);
2932
2933
2934         public delegate Efl.TextFormatWrap efl_text_wrap_get_api_delegate(System.IntPtr obj);
2935
2936         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");
2937
2938         private static Efl.TextFormatWrap wrap_get(System.IntPtr obj, System.IntPtr pd)
2939         {
2940             Eina.Log.Debug("function efl_text_wrap_get was called");
2941             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2942             if (ws != null)
2943             {
2944             Efl.TextFormatWrap _ret_var = default(Efl.TextFormatWrap);
2945                 try
2946                 {
2947                     _ret_var = ((ITextInteractive)ws.Target).GetWrap();
2948                 }
2949                 catch (Exception e)
2950                 {
2951                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2952                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2953                 }
2954
2955         return _ret_var;
2956
2957             }
2958             else
2959             {
2960                 return efl_text_wrap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2961             }
2962         }
2963
2964         private static efl_text_wrap_get_delegate efl_text_wrap_get_static_delegate;
2965
2966
2967         private delegate void efl_text_wrap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatWrap wrap);
2968
2969
2970         public delegate void efl_text_wrap_set_api_delegate(System.IntPtr obj,  Efl.TextFormatWrap wrap);
2971
2972         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");
2973
2974         private static void wrap_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatWrap wrap)
2975         {
2976             Eina.Log.Debug("function efl_text_wrap_set was called");
2977             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2978             if (ws != null)
2979             {
2980
2981                 try
2982                 {
2983                     ((ITextInteractive)ws.Target).SetWrap(wrap);
2984                 }
2985                 catch (Exception e)
2986                 {
2987                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2988                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2989                 }
2990
2991
2992             }
2993             else
2994             {
2995                 efl_text_wrap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), wrap);
2996             }
2997         }
2998
2999         private static efl_text_wrap_set_delegate efl_text_wrap_set_static_delegate;
3000
3001         [return: MarshalAs(UnmanagedType.U1)]
3002         private delegate bool efl_text_multiline_get_delegate(System.IntPtr obj, System.IntPtr pd);
3003
3004         [return: MarshalAs(UnmanagedType.U1)]
3005         public delegate bool efl_text_multiline_get_api_delegate(System.IntPtr obj);
3006
3007         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");
3008
3009         private static bool multiline_get(System.IntPtr obj, System.IntPtr pd)
3010         {
3011             Eina.Log.Debug("function efl_text_multiline_get was called");
3012             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3013             if (ws != null)
3014             {
3015             bool _ret_var = default(bool);
3016                 try
3017                 {
3018                     _ret_var = ((ITextInteractive)ws.Target).GetMultiline();
3019                 }
3020                 catch (Exception e)
3021                 {
3022                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3023                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3024                 }
3025
3026         return _ret_var;
3027
3028             }
3029             else
3030             {
3031                 return efl_text_multiline_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3032             }
3033         }
3034
3035         private static efl_text_multiline_get_delegate efl_text_multiline_get_static_delegate;
3036
3037
3038         private delegate void efl_text_multiline_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
3039
3040
3041         public delegate void efl_text_multiline_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
3042
3043         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");
3044
3045         private static void multiline_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
3046         {
3047             Eina.Log.Debug("function efl_text_multiline_set was called");
3048             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3049             if (ws != null)
3050             {
3051
3052                 try
3053                 {
3054                     ((ITextInteractive)ws.Target).SetMultiline(enabled);
3055                 }
3056                 catch (Exception e)
3057                 {
3058                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3059                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3060                 }
3061
3062
3063             }
3064             else
3065             {
3066                 efl_text_multiline_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
3067             }
3068         }
3069
3070         private static efl_text_multiline_set_delegate efl_text_multiline_set_static_delegate;
3071
3072
3073         private delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
3074
3075
3076         public delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_api_delegate(System.IntPtr obj);
3077
3078         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");
3079
3080         private static Efl.TextFormatHorizontalAlignmentAutoType halign_auto_type_get(System.IntPtr obj, System.IntPtr pd)
3081         {
3082             Eina.Log.Debug("function efl_text_halign_auto_type_get was called");
3083             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3084             if (ws != null)
3085             {
3086             Efl.TextFormatHorizontalAlignmentAutoType _ret_var = default(Efl.TextFormatHorizontalAlignmentAutoType);
3087                 try
3088                 {
3089                     _ret_var = ((ITextInteractive)ws.Target).GetHalignAutoType();
3090                 }
3091                 catch (Exception e)
3092                 {
3093                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3094                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3095                 }
3096
3097         return _ret_var;
3098
3099             }
3100             else
3101             {
3102                 return efl_text_halign_auto_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3103             }
3104         }
3105
3106         private static efl_text_halign_auto_type_get_delegate efl_text_halign_auto_type_get_static_delegate;
3107
3108
3109         private delegate void efl_text_halign_auto_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatHorizontalAlignmentAutoType value);
3110
3111
3112         public delegate void efl_text_halign_auto_type_set_api_delegate(System.IntPtr obj,  Efl.TextFormatHorizontalAlignmentAutoType value);
3113
3114         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");
3115
3116         private static void halign_auto_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatHorizontalAlignmentAutoType value)
3117         {
3118             Eina.Log.Debug("function efl_text_halign_auto_type_set was called");
3119             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3120             if (ws != null)
3121             {
3122
3123                 try
3124                 {
3125                     ((ITextInteractive)ws.Target).SetHalignAutoType(value);
3126                 }
3127                 catch (Exception e)
3128                 {
3129                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3130                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3131                 }
3132
3133
3134             }
3135             else
3136             {
3137                 efl_text_halign_auto_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3138             }
3139         }
3140
3141         private static efl_text_halign_auto_type_set_delegate efl_text_halign_auto_type_set_static_delegate;
3142
3143
3144         private delegate double efl_text_halign_get_delegate(System.IntPtr obj, System.IntPtr pd);
3145
3146
3147         public delegate double efl_text_halign_get_api_delegate(System.IntPtr obj);
3148
3149         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");
3150
3151         private static double halign_get(System.IntPtr obj, System.IntPtr pd)
3152         {
3153             Eina.Log.Debug("function efl_text_halign_get was called");
3154             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3155             if (ws != null)
3156             {
3157             double _ret_var = default(double);
3158                 try
3159                 {
3160                     _ret_var = ((ITextInteractive)ws.Target).GetHalign();
3161                 }
3162                 catch (Exception e)
3163                 {
3164                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3165                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3166                 }
3167
3168         return _ret_var;
3169
3170             }
3171             else
3172             {
3173                 return efl_text_halign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3174             }
3175         }
3176
3177         private static efl_text_halign_get_delegate efl_text_halign_get_static_delegate;
3178
3179
3180         private delegate void efl_text_halign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
3181
3182
3183         public delegate void efl_text_halign_set_api_delegate(System.IntPtr obj,  double value);
3184
3185         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");
3186
3187         private static void halign_set(System.IntPtr obj, System.IntPtr pd, double value)
3188         {
3189             Eina.Log.Debug("function efl_text_halign_set was called");
3190             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3191             if (ws != null)
3192             {
3193
3194                 try
3195                 {
3196                     ((ITextInteractive)ws.Target).SetHalign(value);
3197                 }
3198                 catch (Exception e)
3199                 {
3200                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3201                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3202                 }
3203
3204
3205             }
3206             else
3207             {
3208                 efl_text_halign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3209             }
3210         }
3211
3212         private static efl_text_halign_set_delegate efl_text_halign_set_static_delegate;
3213
3214
3215         private delegate double efl_text_valign_get_delegate(System.IntPtr obj, System.IntPtr pd);
3216
3217
3218         public delegate double efl_text_valign_get_api_delegate(System.IntPtr obj);
3219
3220         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");
3221
3222         private static double valign_get(System.IntPtr obj, System.IntPtr pd)
3223         {
3224             Eina.Log.Debug("function efl_text_valign_get was called");
3225             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3226             if (ws != null)
3227             {
3228             double _ret_var = default(double);
3229                 try
3230                 {
3231                     _ret_var = ((ITextInteractive)ws.Target).GetValign();
3232                 }
3233                 catch (Exception e)
3234                 {
3235                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3236                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3237                 }
3238
3239         return _ret_var;
3240
3241             }
3242             else
3243             {
3244                 return efl_text_valign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3245             }
3246         }
3247
3248         private static efl_text_valign_get_delegate efl_text_valign_get_static_delegate;
3249
3250
3251         private delegate void efl_text_valign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
3252
3253
3254         public delegate void efl_text_valign_set_api_delegate(System.IntPtr obj,  double value);
3255
3256         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");
3257
3258         private static void valign_set(System.IntPtr obj, System.IntPtr pd, double value)
3259         {
3260             Eina.Log.Debug("function efl_text_valign_set was called");
3261             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3262             if (ws != null)
3263             {
3264
3265                 try
3266                 {
3267                     ((ITextInteractive)ws.Target).SetValign(value);
3268                 }
3269                 catch (Exception e)
3270                 {
3271                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3272                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3273                 }
3274
3275
3276             }
3277             else
3278             {
3279                 efl_text_valign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3280             }
3281         }
3282
3283         private static efl_text_valign_set_delegate efl_text_valign_set_static_delegate;
3284
3285
3286         private delegate double efl_text_linegap_get_delegate(System.IntPtr obj, System.IntPtr pd);
3287
3288
3289         public delegate double efl_text_linegap_get_api_delegate(System.IntPtr obj);
3290
3291         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");
3292
3293         private static double linegap_get(System.IntPtr obj, System.IntPtr pd)
3294         {
3295             Eina.Log.Debug("function efl_text_linegap_get was called");
3296             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3297             if (ws != null)
3298             {
3299             double _ret_var = default(double);
3300                 try
3301                 {
3302                     _ret_var = ((ITextInteractive)ws.Target).GetLinegap();
3303                 }
3304                 catch (Exception e)
3305                 {
3306                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3307                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3308                 }
3309
3310         return _ret_var;
3311
3312             }
3313             else
3314             {
3315                 return efl_text_linegap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3316             }
3317         }
3318
3319         private static efl_text_linegap_get_delegate efl_text_linegap_get_static_delegate;
3320
3321
3322         private delegate void efl_text_linegap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
3323
3324
3325         public delegate void efl_text_linegap_set_api_delegate(System.IntPtr obj,  double value);
3326
3327         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");
3328
3329         private static void linegap_set(System.IntPtr obj, System.IntPtr pd, double value)
3330         {
3331             Eina.Log.Debug("function efl_text_linegap_set was called");
3332             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3333             if (ws != null)
3334             {
3335
3336                 try
3337                 {
3338                     ((ITextInteractive)ws.Target).SetLinegap(value);
3339                 }
3340                 catch (Exception e)
3341                 {
3342                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3343                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3344                 }
3345
3346
3347             }
3348             else
3349             {
3350                 efl_text_linegap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3351             }
3352         }
3353
3354         private static efl_text_linegap_set_delegate efl_text_linegap_set_static_delegate;
3355
3356
3357         private delegate double efl_text_linerelgap_get_delegate(System.IntPtr obj, System.IntPtr pd);
3358
3359
3360         public delegate double efl_text_linerelgap_get_api_delegate(System.IntPtr obj);
3361
3362         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");
3363
3364         private static double linerelgap_get(System.IntPtr obj, System.IntPtr pd)
3365         {
3366             Eina.Log.Debug("function efl_text_linerelgap_get was called");
3367             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3368             if (ws != null)
3369             {
3370             double _ret_var = default(double);
3371                 try
3372                 {
3373                     _ret_var = ((ITextInteractive)ws.Target).GetLinerelgap();
3374                 }
3375                 catch (Exception e)
3376                 {
3377                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3378                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3379                 }
3380
3381         return _ret_var;
3382
3383             }
3384             else
3385             {
3386                 return efl_text_linerelgap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3387             }
3388         }
3389
3390         private static efl_text_linerelgap_get_delegate efl_text_linerelgap_get_static_delegate;
3391
3392
3393         private delegate void efl_text_linerelgap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
3394
3395
3396         public delegate void efl_text_linerelgap_set_api_delegate(System.IntPtr obj,  double value);
3397
3398         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");
3399
3400         private static void linerelgap_set(System.IntPtr obj, System.IntPtr pd, double value)
3401         {
3402             Eina.Log.Debug("function efl_text_linerelgap_set was called");
3403             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3404             if (ws != null)
3405             {
3406
3407                 try
3408                 {
3409                     ((ITextInteractive)ws.Target).SetLinerelgap(value);
3410                 }
3411                 catch (Exception e)
3412                 {
3413                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3414                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3415                 }
3416
3417
3418             }
3419             else
3420             {
3421                 efl_text_linerelgap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3422             }
3423         }
3424
3425         private static efl_text_linerelgap_set_delegate efl_text_linerelgap_set_static_delegate;
3426
3427
3428         private delegate int efl_text_tabstops_get_delegate(System.IntPtr obj, System.IntPtr pd);
3429
3430
3431         public delegate int efl_text_tabstops_get_api_delegate(System.IntPtr obj);
3432
3433         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");
3434
3435         private static int tabstops_get(System.IntPtr obj, System.IntPtr pd)
3436         {
3437             Eina.Log.Debug("function efl_text_tabstops_get was called");
3438             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3439             if (ws != null)
3440             {
3441             int _ret_var = default(int);
3442                 try
3443                 {
3444                     _ret_var = ((ITextInteractive)ws.Target).GetTabstops();
3445                 }
3446                 catch (Exception e)
3447                 {
3448                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3449                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3450                 }
3451
3452         return _ret_var;
3453
3454             }
3455             else
3456             {
3457                 return efl_text_tabstops_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3458             }
3459         }
3460
3461         private static efl_text_tabstops_get_delegate efl_text_tabstops_get_static_delegate;
3462
3463
3464         private delegate void efl_text_tabstops_set_delegate(System.IntPtr obj, System.IntPtr pd,  int value);
3465
3466
3467         public delegate void efl_text_tabstops_set_api_delegate(System.IntPtr obj,  int value);
3468
3469         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");
3470
3471         private static void tabstops_set(System.IntPtr obj, System.IntPtr pd, int value)
3472         {
3473             Eina.Log.Debug("function efl_text_tabstops_set was called");
3474             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3475             if (ws != null)
3476             {
3477
3478                 try
3479                 {
3480                     ((ITextInteractive)ws.Target).SetTabstops(value);
3481                 }
3482                 catch (Exception e)
3483                 {
3484                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3485                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3486                 }
3487
3488
3489             }
3490             else
3491             {
3492                 efl_text_tabstops_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
3493             }
3494         }
3495
3496         private static efl_text_tabstops_set_delegate efl_text_tabstops_set_static_delegate;
3497
3498         [return: MarshalAs(UnmanagedType.U1)]
3499         private delegate bool efl_text_password_get_delegate(System.IntPtr obj, System.IntPtr pd);
3500
3501         [return: MarshalAs(UnmanagedType.U1)]
3502         public delegate bool efl_text_password_get_api_delegate(System.IntPtr obj);
3503
3504         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");
3505
3506         private static bool password_get(System.IntPtr obj, System.IntPtr pd)
3507         {
3508             Eina.Log.Debug("function efl_text_password_get was called");
3509             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3510             if (ws != null)
3511             {
3512             bool _ret_var = default(bool);
3513                 try
3514                 {
3515                     _ret_var = ((ITextInteractive)ws.Target).GetPassword();
3516                 }
3517                 catch (Exception e)
3518                 {
3519                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3520                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3521                 }
3522
3523         return _ret_var;
3524
3525             }
3526             else
3527             {
3528                 return efl_text_password_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3529             }
3530         }
3531
3532         private static efl_text_password_get_delegate efl_text_password_get_static_delegate;
3533
3534
3535         private delegate void efl_text_password_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
3536
3537
3538         public delegate void efl_text_password_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
3539
3540         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");
3541
3542         private static void password_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
3543         {
3544             Eina.Log.Debug("function efl_text_password_set was called");
3545             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3546             if (ws != null)
3547             {
3548
3549                 try
3550                 {
3551                     ((ITextInteractive)ws.Target).SetPassword(enabled);
3552                 }
3553                 catch (Exception e)
3554                 {
3555                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3556                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3557                 }
3558
3559
3560             }
3561             else
3562             {
3563                 efl_text_password_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
3564             }
3565         }
3566
3567         private static efl_text_password_set_delegate efl_text_password_set_static_delegate;
3568
3569         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3570         private delegate System.String efl_text_replacement_char_get_delegate(System.IntPtr obj, System.IntPtr pd);
3571
3572         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3573         public delegate System.String efl_text_replacement_char_get_api_delegate(System.IntPtr obj);
3574
3575         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");
3576
3577         private static System.String replacement_char_get(System.IntPtr obj, System.IntPtr pd)
3578         {
3579             Eina.Log.Debug("function efl_text_replacement_char_get was called");
3580             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3581             if (ws != null)
3582             {
3583             System.String _ret_var = default(System.String);
3584                 try
3585                 {
3586                     _ret_var = ((ITextInteractive)ws.Target).GetReplacementChar();
3587                 }
3588                 catch (Exception e)
3589                 {
3590                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3591                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3592                 }
3593
3594         return _ret_var;
3595
3596             }
3597             else
3598             {
3599                 return efl_text_replacement_char_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3600             }
3601         }
3602
3603         private static efl_text_replacement_char_get_delegate efl_text_replacement_char_get_static_delegate;
3604
3605
3606         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);
3607
3608
3609         public delegate void efl_text_replacement_char_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String repch);
3610
3611         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");
3612
3613         private static void replacement_char_set(System.IntPtr obj, System.IntPtr pd, System.String repch)
3614         {
3615             Eina.Log.Debug("function efl_text_replacement_char_set was called");
3616             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3617             if (ws != null)
3618             {
3619
3620                 try
3621                 {
3622                     ((ITextInteractive)ws.Target).SetReplacementChar(repch);
3623                 }
3624                 catch (Exception e)
3625                 {
3626                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3627                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3628                 }
3629
3630
3631             }
3632             else
3633             {
3634                 efl_text_replacement_char_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), repch);
3635             }
3636         }
3637
3638         private static efl_text_replacement_char_set_delegate efl_text_replacement_char_set_static_delegate;
3639
3640
3641         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);
3642
3643
3644         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);
3645
3646         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");
3647
3648         private static void normal_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
3649         {
3650             Eina.Log.Debug("function efl_text_normal_color_get was called");
3651             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3652             if (ws != null)
3653             {
3654                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
3655                 try
3656                 {
3657                     ((ITextInteractive)ws.Target).GetNormalColor(out r, out g, out b, out a);
3658                 }
3659                 catch (Exception e)
3660                 {
3661                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3662                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3663                 }
3664
3665
3666             }
3667             else
3668             {
3669                 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);
3670             }
3671         }
3672
3673         private static efl_text_normal_color_get_delegate efl_text_normal_color_get_static_delegate;
3674
3675
3676         private delegate void efl_text_normal_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
3677
3678
3679         public delegate void efl_text_normal_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
3680
3681         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");
3682
3683         private static void normal_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
3684         {
3685             Eina.Log.Debug("function efl_text_normal_color_set was called");
3686             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3687             if (ws != null)
3688             {
3689
3690                 try
3691                 {
3692                     ((ITextInteractive)ws.Target).SetNormalColor(r, g, b, a);
3693                 }
3694                 catch (Exception e)
3695                 {
3696                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3697                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3698                 }
3699
3700
3701             }
3702             else
3703             {
3704                 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);
3705             }
3706         }
3707
3708         private static efl_text_normal_color_set_delegate efl_text_normal_color_set_static_delegate;
3709
3710
3711         private delegate Efl.TextStyleBackingType efl_text_backing_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
3712
3713
3714         public delegate Efl.TextStyleBackingType efl_text_backing_type_get_api_delegate(System.IntPtr obj);
3715
3716         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");
3717
3718         private static Efl.TextStyleBackingType backing_type_get(System.IntPtr obj, System.IntPtr pd)
3719         {
3720             Eina.Log.Debug("function efl_text_backing_type_get was called");
3721             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3722             if (ws != null)
3723             {
3724             Efl.TextStyleBackingType _ret_var = default(Efl.TextStyleBackingType);
3725                 try
3726                 {
3727                     _ret_var = ((ITextInteractive)ws.Target).GetBackingType();
3728                 }
3729                 catch (Exception e)
3730                 {
3731                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3732                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3733                 }
3734
3735         return _ret_var;
3736
3737             }
3738             else
3739             {
3740                 return efl_text_backing_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3741             }
3742         }
3743
3744         private static efl_text_backing_type_get_delegate efl_text_backing_type_get_static_delegate;
3745
3746
3747         private delegate void efl_text_backing_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleBackingType type);
3748
3749
3750         public delegate void efl_text_backing_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleBackingType type);
3751
3752         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");
3753
3754         private static void backing_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleBackingType type)
3755         {
3756             Eina.Log.Debug("function efl_text_backing_type_set was called");
3757             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3758             if (ws != null)
3759             {
3760
3761                 try
3762                 {
3763                     ((ITextInteractive)ws.Target).SetBackingType(type);
3764                 }
3765                 catch (Exception e)
3766                 {
3767                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3768                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3769                 }
3770
3771
3772             }
3773             else
3774             {
3775                 efl_text_backing_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
3776             }
3777         }
3778
3779         private static efl_text_backing_type_set_delegate efl_text_backing_type_set_static_delegate;
3780
3781
3782         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);
3783
3784
3785         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);
3786
3787         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");
3788
3789         private static void backing_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
3790         {
3791             Eina.Log.Debug("function efl_text_backing_color_get was called");
3792             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3793             if (ws != null)
3794             {
3795                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
3796                 try
3797                 {
3798                     ((ITextInteractive)ws.Target).GetBackingColor(out r, out g, out b, out a);
3799                 }
3800                 catch (Exception e)
3801                 {
3802                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3803                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3804                 }
3805
3806
3807             }
3808             else
3809             {
3810                 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);
3811             }
3812         }
3813
3814         private static efl_text_backing_color_get_delegate efl_text_backing_color_get_static_delegate;
3815
3816
3817         private delegate void efl_text_backing_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
3818
3819
3820         public delegate void efl_text_backing_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
3821
3822         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");
3823
3824         private static void backing_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
3825         {
3826             Eina.Log.Debug("function efl_text_backing_color_set was called");
3827             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3828             if (ws != null)
3829             {
3830
3831                 try
3832                 {
3833                     ((ITextInteractive)ws.Target).SetBackingColor(r, g, b, a);
3834                 }
3835                 catch (Exception e)
3836                 {
3837                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3838                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3839                 }
3840
3841
3842             }
3843             else
3844             {
3845                 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);
3846             }
3847         }
3848
3849         private static efl_text_backing_color_set_delegate efl_text_backing_color_set_static_delegate;
3850
3851
3852         private delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
3853
3854
3855         public delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_api_delegate(System.IntPtr obj);
3856
3857         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");
3858
3859         private static Efl.TextStyleUnderlineType underline_type_get(System.IntPtr obj, System.IntPtr pd)
3860         {
3861             Eina.Log.Debug("function efl_text_underline_type_get was called");
3862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3863             if (ws != null)
3864             {
3865             Efl.TextStyleUnderlineType _ret_var = default(Efl.TextStyleUnderlineType);
3866                 try
3867                 {
3868                     _ret_var = ((ITextInteractive)ws.Target).GetUnderlineType();
3869                 }
3870                 catch (Exception e)
3871                 {
3872                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3873                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3874                 }
3875
3876         return _ret_var;
3877
3878             }
3879             else
3880             {
3881                 return efl_text_underline_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3882             }
3883         }
3884
3885         private static efl_text_underline_type_get_delegate efl_text_underline_type_get_static_delegate;
3886
3887
3888         private delegate void efl_text_underline_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleUnderlineType type);
3889
3890
3891         public delegate void efl_text_underline_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleUnderlineType type);
3892
3893         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");
3894
3895         private static void underline_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleUnderlineType type)
3896         {
3897             Eina.Log.Debug("function efl_text_underline_type_set was called");
3898             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3899             if (ws != null)
3900             {
3901
3902                 try
3903                 {
3904                     ((ITextInteractive)ws.Target).SetUnderlineType(type);
3905                 }
3906                 catch (Exception e)
3907                 {
3908                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3909                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3910                 }
3911
3912
3913             }
3914             else
3915             {
3916                 efl_text_underline_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
3917             }
3918         }
3919
3920         private static efl_text_underline_type_set_delegate efl_text_underline_type_set_static_delegate;
3921
3922
3923         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);
3924
3925
3926         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);
3927
3928         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");
3929
3930         private static void underline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
3931         {
3932             Eina.Log.Debug("function efl_text_underline_color_get was called");
3933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3934             if (ws != null)
3935             {
3936                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
3937                 try
3938                 {
3939                     ((ITextInteractive)ws.Target).GetUnderlineColor(out r, out g, out b, out a);
3940                 }
3941                 catch (Exception e)
3942                 {
3943                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3944                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3945                 }
3946
3947
3948             }
3949             else
3950             {
3951                 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);
3952             }
3953         }
3954
3955         private static efl_text_underline_color_get_delegate efl_text_underline_color_get_static_delegate;
3956
3957
3958         private delegate void efl_text_underline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
3959
3960
3961         public delegate void efl_text_underline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
3962
3963         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");
3964
3965         private static void underline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
3966         {
3967             Eina.Log.Debug("function efl_text_underline_color_set was called");
3968             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3969             if (ws != null)
3970             {
3971
3972                 try
3973                 {
3974                     ((ITextInteractive)ws.Target).SetUnderlineColor(r, g, b, a);
3975                 }
3976                 catch (Exception e)
3977                 {
3978                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3979                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3980                 }
3981
3982
3983             }
3984             else
3985             {
3986                 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);
3987             }
3988         }
3989
3990         private static efl_text_underline_color_set_delegate efl_text_underline_color_set_static_delegate;
3991
3992
3993         private delegate double efl_text_underline_height_get_delegate(System.IntPtr obj, System.IntPtr pd);
3994
3995
3996         public delegate double efl_text_underline_height_get_api_delegate(System.IntPtr obj);
3997
3998         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");
3999
4000         private static double underline_height_get(System.IntPtr obj, System.IntPtr pd)
4001         {
4002             Eina.Log.Debug("function efl_text_underline_height_get was called");
4003             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4004             if (ws != null)
4005             {
4006             double _ret_var = default(double);
4007                 try
4008                 {
4009                     _ret_var = ((ITextInteractive)ws.Target).GetUnderlineHeight();
4010                 }
4011                 catch (Exception e)
4012                 {
4013                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4014                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4015                 }
4016
4017         return _ret_var;
4018
4019             }
4020             else
4021             {
4022                 return efl_text_underline_height_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4023             }
4024         }
4025
4026         private static efl_text_underline_height_get_delegate efl_text_underline_height_get_static_delegate;
4027
4028
4029         private delegate void efl_text_underline_height_set_delegate(System.IntPtr obj, System.IntPtr pd,  double height);
4030
4031
4032         public delegate void efl_text_underline_height_set_api_delegate(System.IntPtr obj,  double height);
4033
4034         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");
4035
4036         private static void underline_height_set(System.IntPtr obj, System.IntPtr pd, double height)
4037         {
4038             Eina.Log.Debug("function efl_text_underline_height_set was called");
4039             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4040             if (ws != null)
4041             {
4042
4043                 try
4044                 {
4045                     ((ITextInteractive)ws.Target).SetUnderlineHeight(height);
4046                 }
4047                 catch (Exception e)
4048                 {
4049                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4050                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4051                 }
4052
4053
4054             }
4055             else
4056             {
4057                 efl_text_underline_height_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), height);
4058             }
4059         }
4060
4061         private static efl_text_underline_height_set_delegate efl_text_underline_height_set_static_delegate;
4062
4063
4064         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);
4065
4066
4067         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);
4068
4069         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");
4070
4071         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)
4072         {
4073             Eina.Log.Debug("function efl_text_underline_dashed_color_get was called");
4074             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4075             if (ws != null)
4076             {
4077                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4078                 try
4079                 {
4080                     ((ITextInteractive)ws.Target).GetUnderlineDashedColor(out r, out g, out b, out a);
4081                 }
4082                 catch (Exception e)
4083                 {
4084                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4085                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4086                 }
4087
4088
4089             }
4090             else
4091             {
4092                 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);
4093             }
4094         }
4095
4096         private static efl_text_underline_dashed_color_get_delegate efl_text_underline_dashed_color_get_static_delegate;
4097
4098
4099         private delegate void efl_text_underline_dashed_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4100
4101
4102         public delegate void efl_text_underline_dashed_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4103
4104         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");
4105
4106         private static void underline_dashed_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4107         {
4108             Eina.Log.Debug("function efl_text_underline_dashed_color_set was called");
4109             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4110             if (ws != null)
4111             {
4112
4113                 try
4114                 {
4115                     ((ITextInteractive)ws.Target).SetUnderlineDashedColor(r, g, b, a);
4116                 }
4117                 catch (Exception e)
4118                 {
4119                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4120                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4121                 }
4122
4123
4124             }
4125             else
4126             {
4127                 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);
4128             }
4129         }
4130
4131         private static efl_text_underline_dashed_color_set_delegate efl_text_underline_dashed_color_set_static_delegate;
4132
4133
4134         private delegate int efl_text_underline_dashed_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
4135
4136
4137         public delegate int efl_text_underline_dashed_width_get_api_delegate(System.IntPtr obj);
4138
4139         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");
4140
4141         private static int underline_dashed_width_get(System.IntPtr obj, System.IntPtr pd)
4142         {
4143             Eina.Log.Debug("function efl_text_underline_dashed_width_get was called");
4144             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4145             if (ws != null)
4146             {
4147             int _ret_var = default(int);
4148                 try
4149                 {
4150                     _ret_var = ((ITextInteractive)ws.Target).GetUnderlineDashedWidth();
4151                 }
4152                 catch (Exception e)
4153                 {
4154                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4155                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4156                 }
4157
4158         return _ret_var;
4159
4160             }
4161             else
4162             {
4163                 return efl_text_underline_dashed_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4164             }
4165         }
4166
4167         private static efl_text_underline_dashed_width_get_delegate efl_text_underline_dashed_width_get_static_delegate;
4168
4169
4170         private delegate void efl_text_underline_dashed_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  int width);
4171
4172
4173         public delegate void efl_text_underline_dashed_width_set_api_delegate(System.IntPtr obj,  int width);
4174
4175         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");
4176
4177         private static void underline_dashed_width_set(System.IntPtr obj, System.IntPtr pd, int width)
4178         {
4179             Eina.Log.Debug("function efl_text_underline_dashed_width_set was called");
4180             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4181             if (ws != null)
4182             {
4183
4184                 try
4185                 {
4186                     ((ITextInteractive)ws.Target).SetUnderlineDashedWidth(width);
4187                 }
4188                 catch (Exception e)
4189                 {
4190                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4191                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4192                 }
4193
4194
4195             }
4196             else
4197             {
4198                 efl_text_underline_dashed_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
4199             }
4200         }
4201
4202         private static efl_text_underline_dashed_width_set_delegate efl_text_underline_dashed_width_set_static_delegate;
4203
4204
4205         private delegate int efl_text_underline_dashed_gap_get_delegate(System.IntPtr obj, System.IntPtr pd);
4206
4207
4208         public delegate int efl_text_underline_dashed_gap_get_api_delegate(System.IntPtr obj);
4209
4210         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");
4211
4212         private static int underline_dashed_gap_get(System.IntPtr obj, System.IntPtr pd)
4213         {
4214             Eina.Log.Debug("function efl_text_underline_dashed_gap_get was called");
4215             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4216             if (ws != null)
4217             {
4218             int _ret_var = default(int);
4219                 try
4220                 {
4221                     _ret_var = ((ITextInteractive)ws.Target).GetUnderlineDashedGap();
4222                 }
4223                 catch (Exception e)
4224                 {
4225                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4226                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4227                 }
4228
4229         return _ret_var;
4230
4231             }
4232             else
4233             {
4234                 return efl_text_underline_dashed_gap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4235             }
4236         }
4237
4238         private static efl_text_underline_dashed_gap_get_delegate efl_text_underline_dashed_gap_get_static_delegate;
4239
4240
4241         private delegate void efl_text_underline_dashed_gap_set_delegate(System.IntPtr obj, System.IntPtr pd,  int gap);
4242
4243
4244         public delegate void efl_text_underline_dashed_gap_set_api_delegate(System.IntPtr obj,  int gap);
4245
4246         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");
4247
4248         private static void underline_dashed_gap_set(System.IntPtr obj, System.IntPtr pd, int gap)
4249         {
4250             Eina.Log.Debug("function efl_text_underline_dashed_gap_set was called");
4251             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4252             if (ws != null)
4253             {
4254
4255                 try
4256                 {
4257                     ((ITextInteractive)ws.Target).SetUnderlineDashedGap(gap);
4258                 }
4259                 catch (Exception e)
4260                 {
4261                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4262                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4263                 }
4264
4265
4266             }
4267             else
4268             {
4269                 efl_text_underline_dashed_gap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gap);
4270             }
4271         }
4272
4273         private static efl_text_underline_dashed_gap_set_delegate efl_text_underline_dashed_gap_set_static_delegate;
4274
4275
4276         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);
4277
4278
4279         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);
4280
4281         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");
4282
4283         private static void underline2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4284         {
4285             Eina.Log.Debug("function efl_text_underline2_color_get was called");
4286             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4287             if (ws != null)
4288             {
4289                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4290                 try
4291                 {
4292                     ((ITextInteractive)ws.Target).GetUnderline2Color(out r, out g, out b, out a);
4293                 }
4294                 catch (Exception e)
4295                 {
4296                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4297                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4298                 }
4299
4300
4301             }
4302             else
4303             {
4304                 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);
4305             }
4306         }
4307
4308         private static efl_text_underline2_color_get_delegate efl_text_underline2_color_get_static_delegate;
4309
4310
4311         private delegate void efl_text_underline2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4312
4313
4314         public delegate void efl_text_underline2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4315
4316         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");
4317
4318         private static void underline2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4319         {
4320             Eina.Log.Debug("function efl_text_underline2_color_set was called");
4321             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4322             if (ws != null)
4323             {
4324
4325                 try
4326                 {
4327                     ((ITextInteractive)ws.Target).SetUnderline2Color(r, g, b, a);
4328                 }
4329                 catch (Exception e)
4330                 {
4331                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4332                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4333                 }
4334
4335
4336             }
4337             else
4338             {
4339                 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);
4340             }
4341         }
4342
4343         private static efl_text_underline2_color_set_delegate efl_text_underline2_color_set_static_delegate;
4344
4345
4346         private delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
4347
4348
4349         public delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_api_delegate(System.IntPtr obj);
4350
4351         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");
4352
4353         private static Efl.TextStyleStrikethroughType strikethrough_type_get(System.IntPtr obj, System.IntPtr pd)
4354         {
4355             Eina.Log.Debug("function efl_text_strikethrough_type_get was called");
4356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4357             if (ws != null)
4358             {
4359             Efl.TextStyleStrikethroughType _ret_var = default(Efl.TextStyleStrikethroughType);
4360                 try
4361                 {
4362                     _ret_var = ((ITextInteractive)ws.Target).GetStrikethroughType();
4363                 }
4364                 catch (Exception e)
4365                 {
4366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4368                 }
4369
4370         return _ret_var;
4371
4372             }
4373             else
4374             {
4375                 return efl_text_strikethrough_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4376             }
4377         }
4378
4379         private static efl_text_strikethrough_type_get_delegate efl_text_strikethrough_type_get_static_delegate;
4380
4381
4382         private delegate void efl_text_strikethrough_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleStrikethroughType type);
4383
4384
4385         public delegate void efl_text_strikethrough_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleStrikethroughType type);
4386
4387         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");
4388
4389         private static void strikethrough_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleStrikethroughType type)
4390         {
4391             Eina.Log.Debug("function efl_text_strikethrough_type_set was called");
4392             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4393             if (ws != null)
4394             {
4395
4396                 try
4397                 {
4398                     ((ITextInteractive)ws.Target).SetStrikethroughType(type);
4399                 }
4400                 catch (Exception e)
4401                 {
4402                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4403                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4404                 }
4405
4406
4407             }
4408             else
4409             {
4410                 efl_text_strikethrough_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
4411             }
4412         }
4413
4414         private static efl_text_strikethrough_type_set_delegate efl_text_strikethrough_type_set_static_delegate;
4415
4416
4417         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);
4418
4419
4420         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);
4421
4422         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");
4423
4424         private static void strikethrough_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4425         {
4426             Eina.Log.Debug("function efl_text_strikethrough_color_get was called");
4427             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4428             if (ws != null)
4429             {
4430                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4431                 try
4432                 {
4433                     ((ITextInteractive)ws.Target).GetStrikethroughColor(out r, out g, out b, out a);
4434                 }
4435                 catch (Exception e)
4436                 {
4437                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4438                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4439                 }
4440
4441
4442             }
4443             else
4444             {
4445                 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);
4446             }
4447         }
4448
4449         private static efl_text_strikethrough_color_get_delegate efl_text_strikethrough_color_get_static_delegate;
4450
4451
4452         private delegate void efl_text_strikethrough_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4453
4454
4455         public delegate void efl_text_strikethrough_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4456
4457         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");
4458
4459         private static void strikethrough_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4460         {
4461             Eina.Log.Debug("function efl_text_strikethrough_color_set was called");
4462             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4463             if (ws != null)
4464             {
4465
4466                 try
4467                 {
4468                     ((ITextInteractive)ws.Target).SetStrikethroughColor(r, g, b, a);
4469                 }
4470                 catch (Exception e)
4471                 {
4472                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4473                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4474                 }
4475
4476
4477             }
4478             else
4479             {
4480                 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);
4481             }
4482         }
4483
4484         private static efl_text_strikethrough_color_set_delegate efl_text_strikethrough_color_set_static_delegate;
4485
4486
4487         private delegate Efl.TextStyleEffectType efl_text_effect_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
4488
4489
4490         public delegate Efl.TextStyleEffectType efl_text_effect_type_get_api_delegate(System.IntPtr obj);
4491
4492         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");
4493
4494         private static Efl.TextStyleEffectType effect_type_get(System.IntPtr obj, System.IntPtr pd)
4495         {
4496             Eina.Log.Debug("function efl_text_effect_type_get was called");
4497             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4498             if (ws != null)
4499             {
4500             Efl.TextStyleEffectType _ret_var = default(Efl.TextStyleEffectType);
4501                 try
4502                 {
4503                     _ret_var = ((ITextInteractive)ws.Target).GetEffectType();
4504                 }
4505                 catch (Exception e)
4506                 {
4507                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4508                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4509                 }
4510
4511         return _ret_var;
4512
4513             }
4514             else
4515             {
4516                 return efl_text_effect_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4517             }
4518         }
4519
4520         private static efl_text_effect_type_get_delegate efl_text_effect_type_get_static_delegate;
4521
4522
4523         private delegate void efl_text_effect_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleEffectType type);
4524
4525
4526         public delegate void efl_text_effect_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleEffectType type);
4527
4528         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");
4529
4530         private static void effect_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleEffectType type)
4531         {
4532             Eina.Log.Debug("function efl_text_effect_type_set was called");
4533             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4534             if (ws != null)
4535             {
4536
4537                 try
4538                 {
4539                     ((ITextInteractive)ws.Target).SetEffectType(type);
4540                 }
4541                 catch (Exception e)
4542                 {
4543                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4544                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4545                 }
4546
4547
4548             }
4549             else
4550             {
4551                 efl_text_effect_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
4552             }
4553         }
4554
4555         private static efl_text_effect_type_set_delegate efl_text_effect_type_set_static_delegate;
4556
4557
4558         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);
4559
4560
4561         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);
4562
4563         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");
4564
4565         private static void outline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4566         {
4567             Eina.Log.Debug("function efl_text_outline_color_get was called");
4568             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4569             if (ws != null)
4570             {
4571                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4572                 try
4573                 {
4574                     ((ITextInteractive)ws.Target).GetOutlineColor(out r, out g, out b, out a);
4575                 }
4576                 catch (Exception e)
4577                 {
4578                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4579                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4580                 }
4581
4582
4583             }
4584             else
4585             {
4586                 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);
4587             }
4588         }
4589
4590         private static efl_text_outline_color_get_delegate efl_text_outline_color_get_static_delegate;
4591
4592
4593         private delegate void efl_text_outline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4594
4595
4596         public delegate void efl_text_outline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4597
4598         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");
4599
4600         private static void outline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4601         {
4602             Eina.Log.Debug("function efl_text_outline_color_set was called");
4603             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4604             if (ws != null)
4605             {
4606
4607                 try
4608                 {
4609                     ((ITextInteractive)ws.Target).SetOutlineColor(r, g, b, a);
4610                 }
4611                 catch (Exception e)
4612                 {
4613                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4614                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4615                 }
4616
4617
4618             }
4619             else
4620             {
4621                 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);
4622             }
4623         }
4624
4625         private static efl_text_outline_color_set_delegate efl_text_outline_color_set_static_delegate;
4626
4627
4628         private delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
4629
4630
4631         public delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_api_delegate(System.IntPtr obj);
4632
4633         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");
4634
4635         private static Efl.TextStyleShadowDirection shadow_direction_get(System.IntPtr obj, System.IntPtr pd)
4636         {
4637             Eina.Log.Debug("function efl_text_shadow_direction_get was called");
4638             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4639             if (ws != null)
4640             {
4641             Efl.TextStyleShadowDirection _ret_var = default(Efl.TextStyleShadowDirection);
4642                 try
4643                 {
4644                     _ret_var = ((ITextInteractive)ws.Target).GetShadowDirection();
4645                 }
4646                 catch (Exception e)
4647                 {
4648                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4649                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4650                 }
4651
4652         return _ret_var;
4653
4654             }
4655             else
4656             {
4657                 return efl_text_shadow_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4658             }
4659         }
4660
4661         private static efl_text_shadow_direction_get_delegate efl_text_shadow_direction_get_static_delegate;
4662
4663
4664         private delegate void efl_text_shadow_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleShadowDirection type);
4665
4666
4667         public delegate void efl_text_shadow_direction_set_api_delegate(System.IntPtr obj,  Efl.TextStyleShadowDirection type);
4668
4669         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");
4670
4671         private static void shadow_direction_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleShadowDirection type)
4672         {
4673             Eina.Log.Debug("function efl_text_shadow_direction_set was called");
4674             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4675             if (ws != null)
4676             {
4677
4678                 try
4679                 {
4680                     ((ITextInteractive)ws.Target).SetShadowDirection(type);
4681                 }
4682                 catch (Exception e)
4683                 {
4684                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4685                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4686                 }
4687
4688
4689             }
4690             else
4691             {
4692                 efl_text_shadow_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
4693             }
4694         }
4695
4696         private static efl_text_shadow_direction_set_delegate efl_text_shadow_direction_set_static_delegate;
4697
4698
4699         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);
4700
4701
4702         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);
4703
4704         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");
4705
4706         private static void shadow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4707         {
4708             Eina.Log.Debug("function efl_text_shadow_color_get was called");
4709             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4710             if (ws != null)
4711             {
4712                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4713                 try
4714                 {
4715                     ((ITextInteractive)ws.Target).GetShadowColor(out r, out g, out b, out a);
4716                 }
4717                 catch (Exception e)
4718                 {
4719                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4720                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4721                 }
4722
4723
4724             }
4725             else
4726             {
4727                 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);
4728             }
4729         }
4730
4731         private static efl_text_shadow_color_get_delegate efl_text_shadow_color_get_static_delegate;
4732
4733
4734         private delegate void efl_text_shadow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4735
4736
4737         public delegate void efl_text_shadow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4738
4739         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");
4740
4741         private static void shadow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4742         {
4743             Eina.Log.Debug("function efl_text_shadow_color_set was called");
4744             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4745             if (ws != null)
4746             {
4747
4748                 try
4749                 {
4750                     ((ITextInteractive)ws.Target).SetShadowColor(r, g, b, a);
4751                 }
4752                 catch (Exception e)
4753                 {
4754                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4755                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4756                 }
4757
4758
4759             }
4760             else
4761             {
4762                 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);
4763             }
4764         }
4765
4766         private static efl_text_shadow_color_set_delegate efl_text_shadow_color_set_static_delegate;
4767
4768
4769         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);
4770
4771
4772         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);
4773
4774         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");
4775
4776         private static void glow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4777         {
4778             Eina.Log.Debug("function efl_text_glow_color_get was called");
4779             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4780             if (ws != null)
4781             {
4782                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4783                 try
4784                 {
4785                     ((ITextInteractive)ws.Target).GetGlowColor(out r, out g, out b, out a);
4786                 }
4787                 catch (Exception e)
4788                 {
4789                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4790                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4791                 }
4792
4793
4794             }
4795             else
4796             {
4797                 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);
4798             }
4799         }
4800
4801         private static efl_text_glow_color_get_delegate efl_text_glow_color_get_static_delegate;
4802
4803
4804         private delegate void efl_text_glow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4805
4806
4807         public delegate void efl_text_glow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4808
4809         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");
4810
4811         private static void glow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4812         {
4813             Eina.Log.Debug("function efl_text_glow_color_set was called");
4814             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4815             if (ws != null)
4816             {
4817
4818                 try
4819                 {
4820                     ((ITextInteractive)ws.Target).SetGlowColor(r, g, b, a);
4821                 }
4822                 catch (Exception e)
4823                 {
4824                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4825                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4826                 }
4827
4828
4829             }
4830             else
4831             {
4832                 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);
4833             }
4834         }
4835
4836         private static efl_text_glow_color_set_delegate efl_text_glow_color_set_static_delegate;
4837
4838
4839         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);
4840
4841
4842         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);
4843
4844         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");
4845
4846         private static void glow2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4847         {
4848             Eina.Log.Debug("function efl_text_glow2_color_get was called");
4849             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4850             if (ws != null)
4851             {
4852                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4853                 try
4854                 {
4855                     ((ITextInteractive)ws.Target).GetGlow2Color(out r, out g, out b, out a);
4856                 }
4857                 catch (Exception e)
4858                 {
4859                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4860                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4861                 }
4862
4863
4864             }
4865             else
4866             {
4867                 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);
4868             }
4869         }
4870
4871         private static efl_text_glow2_color_get_delegate efl_text_glow2_color_get_static_delegate;
4872
4873
4874         private delegate void efl_text_glow2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4875
4876
4877         public delegate void efl_text_glow2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4878
4879         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");
4880
4881         private static void glow2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
4882         {
4883             Eina.Log.Debug("function efl_text_glow2_color_set was called");
4884             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4885             if (ws != null)
4886             {
4887
4888                 try
4889                 {
4890                     ((ITextInteractive)ws.Target).SetGlow2Color(r, g, b, a);
4891                 }
4892                 catch (Exception e)
4893                 {
4894                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4895                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4896                 }
4897
4898
4899             }
4900             else
4901             {
4902                 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);
4903             }
4904         }
4905
4906         private static efl_text_glow2_color_set_delegate efl_text_glow2_color_set_static_delegate;
4907
4908         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4909         private delegate System.String efl_text_gfx_filter_get_delegate(System.IntPtr obj, System.IntPtr pd);
4910
4911         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4912         public delegate System.String efl_text_gfx_filter_get_api_delegate(System.IntPtr obj);
4913
4914         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");
4915
4916         private static System.String gfx_filter_get(System.IntPtr obj, System.IntPtr pd)
4917         {
4918             Eina.Log.Debug("function efl_text_gfx_filter_get was called");
4919             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4920             if (ws != null)
4921             {
4922             System.String _ret_var = default(System.String);
4923                 try
4924                 {
4925                     _ret_var = ((ITextInteractive)ws.Target).GetGfxFilter();
4926                 }
4927                 catch (Exception e)
4928                 {
4929                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4930                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4931                 }
4932
4933         return _ret_var;
4934
4935             }
4936             else
4937             {
4938                 return efl_text_gfx_filter_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4939             }
4940         }
4941
4942         private static efl_text_gfx_filter_get_delegate efl_text_gfx_filter_get_static_delegate;
4943
4944
4945         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);
4946
4947
4948         public delegate void efl_text_gfx_filter_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code);
4949
4950         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");
4951
4952         private static void gfx_filter_set(System.IntPtr obj, System.IntPtr pd, System.String code)
4953         {
4954             Eina.Log.Debug("function efl_text_gfx_filter_set was called");
4955             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4956             if (ws != null)
4957             {
4958
4959                 try
4960                 {
4961                     ((ITextInteractive)ws.Target).SetGfxFilter(code);
4962                 }
4963                 catch (Exception e)
4964                 {
4965                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4966                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4967                 }
4968
4969
4970             }
4971             else
4972             {
4973                 efl_text_gfx_filter_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code);
4974             }
4975         }
4976
4977         private static efl_text_gfx_filter_set_delegate efl_text_gfx_filter_set_static_delegate;
4978
4979         #pragma warning restore CA1707, CS1591, SA1300, SA1600
4980
4981 }
4982 }
4983 }
4984
4985 #if EFL_BETA
4986 #pragma warning disable CS1591
4987 public static class EflITextInteractiveConcrete_ExtensionMethods {
4988     public static Efl.BindableProperty<bool> SelectionAllowed<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
4989         return new Efl.BindableProperty<bool>("selection_allowed", fac);
4990     }
4991
4992
4993     public static Efl.BindableProperty<bool> Editable<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
4994         return new Efl.BindableProperty<bool>("editable", fac);
4995     }
4996
4997
4998
4999     public static Efl.BindableProperty<System.String> FontSource<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5000         return new Efl.BindableProperty<System.String>("font_source", fac);
5001     }
5002
5003     public static Efl.BindableProperty<System.String> FontFallbacks<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5004         return new Efl.BindableProperty<System.String>("font_fallbacks", fac);
5005     }
5006
5007     public static Efl.BindableProperty<Efl.TextFontWeight> FontWeight<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5008         return new Efl.BindableProperty<Efl.TextFontWeight>("font_weight", fac);
5009     }
5010
5011     public static Efl.BindableProperty<Efl.TextFontSlant> FontSlant<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5012         return new Efl.BindableProperty<Efl.TextFontSlant>("font_slant", fac);
5013     }
5014
5015     public static Efl.BindableProperty<Efl.TextFontWidth> FontWidth<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5016         return new Efl.BindableProperty<Efl.TextFontWidth>("font_width", fac);
5017     }
5018
5019     public static Efl.BindableProperty<System.String> FontLang<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5020         return new Efl.BindableProperty<System.String>("font_lang", fac);
5021     }
5022
5023     public static Efl.BindableProperty<Efl.TextFontBitmapScalable> FontBitmapScalable<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5024         return new Efl.BindableProperty<Efl.TextFontBitmapScalable>("font_bitmap_scalable", fac);
5025     }
5026
5027     public static Efl.BindableProperty<double> Ellipsis<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5028         return new Efl.BindableProperty<double>("ellipsis", fac);
5029     }
5030
5031     public static Efl.BindableProperty<Efl.TextFormatWrap> Wrap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5032         return new Efl.BindableProperty<Efl.TextFormatWrap>("wrap", fac);
5033     }
5034
5035     public static Efl.BindableProperty<bool> Multiline<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5036         return new Efl.BindableProperty<bool>("multiline", fac);
5037     }
5038
5039     public static Efl.BindableProperty<Efl.TextFormatHorizontalAlignmentAutoType> HalignAutoType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5040         return new Efl.BindableProperty<Efl.TextFormatHorizontalAlignmentAutoType>("halign_auto_type", fac);
5041     }
5042
5043     public static Efl.BindableProperty<double> Halign<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5044         return new Efl.BindableProperty<double>("halign", fac);
5045     }
5046
5047     public static Efl.BindableProperty<double> Valign<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5048         return new Efl.BindableProperty<double>("valign", fac);
5049     }
5050
5051     public static Efl.BindableProperty<double> Linegap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5052         return new Efl.BindableProperty<double>("linegap", fac);
5053     }
5054
5055     public static Efl.BindableProperty<double> Linerelgap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5056         return new Efl.BindableProperty<double>("linerelgap", fac);
5057     }
5058
5059     public static Efl.BindableProperty<int> Tabstops<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5060         return new Efl.BindableProperty<int>("tabstops", fac);
5061     }
5062
5063     public static Efl.BindableProperty<bool> Password<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5064         return new Efl.BindableProperty<bool>("password", fac);
5065     }
5066
5067     public static Efl.BindableProperty<System.String> ReplacementChar<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5068         return new Efl.BindableProperty<System.String>("replacement_char", fac);
5069     }
5070
5071
5072     public static Efl.BindableProperty<Efl.TextStyleBackingType> BackingType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5073         return new Efl.BindableProperty<Efl.TextStyleBackingType>("backing_type", fac);
5074     }
5075
5076
5077     public static Efl.BindableProperty<Efl.TextStyleUnderlineType> UnderlineType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5078         return new Efl.BindableProperty<Efl.TextStyleUnderlineType>("underline_type", fac);
5079     }
5080
5081
5082     public static Efl.BindableProperty<double> UnderlineHeight<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5083         return new Efl.BindableProperty<double>("underline_height", fac);
5084     }
5085
5086
5087     public static Efl.BindableProperty<int> UnderlineDashedWidth<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5088         return new Efl.BindableProperty<int>("underline_dashed_width", fac);
5089     }
5090
5091     public static Efl.BindableProperty<int> UnderlineDashedGap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5092         return new Efl.BindableProperty<int>("underline_dashed_gap", fac);
5093     }
5094
5095
5096     public static Efl.BindableProperty<Efl.TextStyleStrikethroughType> StrikethroughType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5097         return new Efl.BindableProperty<Efl.TextStyleStrikethroughType>("strikethrough_type", fac);
5098     }
5099
5100
5101     public static Efl.BindableProperty<Efl.TextStyleEffectType> EffectType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5102         return new Efl.BindableProperty<Efl.TextStyleEffectType>("effect_type", fac);
5103     }
5104
5105
5106     public static Efl.BindableProperty<Efl.TextStyleShadowDirection> ShadowDirection<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5107         return new Efl.BindableProperty<Efl.TextStyleShadowDirection>("shadow_direction", fac);
5108     }
5109
5110
5111
5112
5113     public static Efl.BindableProperty<System.String> GfxFilter<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.ITextInteractive, T>magic = null) where T : Efl.ITextInteractive {
5114         return new Efl.BindableProperty<System.String>("gfx_filter", fac);
5115     }
5116
5117 }
5118 #pragma warning restore CS1591
5119 #endif