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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Represents a TEXT part of a layout
  13 /// Its lifetime is limited to one function call only, unless an extra reference is explicitly held.</summary>
  14 [Efl.Canvas.LayoutPartText.NativeMethods]
  15 public class LayoutPartText : Efl.Canvas.LayoutPart, Efl.IText, Efl.ITextCursor, Efl.ITextFont, Efl.ITextFormat, Efl.ITextMarkup, Efl.ITextMarkupInteractive, Efl.ITextStyle
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(LayoutPartText))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  34         efl_canvas_layout_part_text_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="LayoutPartText"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public LayoutPartText(Efl.Object parent= null
  38             ) : base(efl_canvas_layout_part_text_class_get(), typeof(LayoutPartText), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Initializes a new instance of the <see cref="LayoutPartText"/> class.
  44     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  45     /// <param name="raw">The native pointer to be wrapped.</param>
  46     protected LayoutPartText(System.IntPtr raw) : base(raw)
  47     {
  48     }
  49
  50     /// <summary>Initializes a new instance of the <see cref="LayoutPartText"/> class.
  51     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  52     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  53     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  54     /// <param name="parent">The Efl.Object parent of this instance.</param>
  55     protected LayoutPartText(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  56     {
  57     }
  58
  59     /// <summary>Sizing policy for text parts.
  60     /// This will determine whether to consider height or width constraints, if text-specific behaviors occur (such as ellipsis, line-wrapping etc.</summary>
  61     virtual public Efl.Canvas.LayoutPartTextExpand GetTextExpand() {
  62          var _ret_var = Efl.Canvas.LayoutPartText.NativeMethods.efl_canvas_layout_part_text_expand_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  63         Eina.Error.RaiseIfUnhandledException();
  64         return _ret_var;
  65  }
  66     /// <summary>Sizing policy for text parts.
  67     /// This will determine whether to consider height or width constraints, if text-specific behaviors occur (such as ellipsis, line-wrapping etc.</summary>
  68     virtual public void SetTextExpand(Efl.Canvas.LayoutPartTextExpand type) {
  69                                  Efl.Canvas.LayoutPartText.NativeMethods.efl_canvas_layout_part_text_expand_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
  70         Eina.Error.RaiseIfUnhandledException();
  71                          }
  72     /// <summary>Retrieves the text string currently being displayed by the given text object.
  73     /// Do not free() the return value.
  74     ///
  75     /// See also <see cref="Efl.IText.GetText"/>.
  76     /// (Since EFL 1.22)</summary>
  77     /// <returns>Text string to display on it.</returns>
  78     virtual public System.String GetText() {
  79          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  80         Eina.Error.RaiseIfUnhandledException();
  81         return _ret_var;
  82  }
  83     /// <summary>Sets the text string to be displayed by the given text object.
  84     /// See also <see cref="Efl.IText.GetText"/>.
  85     /// (Since EFL 1.22)</summary>
  86     /// <param name="text">Text string to display on it.</param>
  87     virtual public void SetText(System.String text) {
  88                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),text);
  89         Eina.Error.RaiseIfUnhandledException();
  90                          }
  91     /// <summary>The object&apos;s main cursor.</summary>
  92     /// <param name="get_type">Cursor type</param>
  93     /// <returns>Text cursor object</returns>
  94     virtual public Efl.TextCursorCursor GetTextCursor(Efl.TextCursorGetType get_type) {
  95                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),get_type);
  96         Eina.Error.RaiseIfUnhandledException();
  97                         return _ret_var;
  98  }
  99     /// <summary>Cursor position</summary>
 100     /// <param name="cur">Cursor object</param>
 101     /// <returns>Cursor position</returns>
 102     virtual public int GetCursorPosition(Efl.TextCursorCursor cur) {
 103                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 104         Eina.Error.RaiseIfUnhandledException();
 105                         return _ret_var;
 106  }
 107     /// <summary>Cursor position</summary>
 108     /// <param name="cur">Cursor object</param>
 109     /// <param name="position">Cursor position</param>
 110     virtual public void SetCursorPosition(Efl.TextCursorCursor cur, int position) {
 111                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, position);
 112         Eina.Error.RaiseIfUnhandledException();
 113                                          }
 114     /// <summary>The content of the cursor (the character under the cursor)</summary>
 115     /// <param name="cur">Cursor object</param>
 116     /// <returns>The unicode codepoint of the character</returns>
 117     virtual public Eina.Unicode GetCursorContent(Efl.TextCursorCursor cur) {
 118                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 119         Eina.Error.RaiseIfUnhandledException();
 120                         return _ret_var;
 121  }
 122     /// <summary>Returns the geometry of two cursors (&quot;split cursor&quot;), if logical cursor is between LTR/RTL text, also considering paragraph direction. Upper cursor is shown for the text of the same direction as paragraph, lower cursor - for opposite.
 123     /// Split cursor geometry is valid only  in &apos;|&apos; cursor mode. In this case <c>true</c> is returned and <c>cx2</c>, <c>cy2</c>, <c>cw2</c>, <c>ch2</c> are set.</summary>
 124     /// <param name="cur">Cursor object</param>
 125     /// <param name="ctype">The type of the cursor.</param>
 126     /// <param name="cx">The x of the cursor (or upper cursor)</param>
 127     /// <param name="cy">The y of the cursor (or upper cursor)</param>
 128     /// <param name="cw">The width of the cursor (or upper cursor)</param>
 129     /// <param name="ch">The height of the cursor (or upper cursor)</param>
 130     /// <param name="cx2">The x of the lower cursor</param>
 131     /// <param name="cy2">The y of the lower cursor</param>
 132     /// <param name="cw2">The width of the lower cursor</param>
 133     /// <param name="ch2">The height of the lower cursor</param>
 134     /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
 135     virtual public bool GetCursorGeometry(Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2) {
 136                                                                                                                                                                                                                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
 137         Eina.Error.RaiseIfUnhandledException();
 138                                                                                                                                                                         return _ret_var;
 139  }
 140     /// <summary>Create new cursor</summary>
 141     /// <returns>Cursor object</returns>
 142     virtual public Efl.TextCursorCursor NewCursor() {
 143          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_new_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 144         Eina.Error.RaiseIfUnhandledException();
 145         return _ret_var;
 146  }
 147     /// <summary>Free existing cursor</summary>
 148     /// <param name="cur">Cursor object</param>
 149     virtual public void CursorFree(Efl.TextCursorCursor cur) {
 150                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_free_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 151         Eina.Error.RaiseIfUnhandledException();
 152                          }
 153     /// <summary>Check if two cursors are equal</summary>
 154     /// <param name="cur1">Cursor 1 object</param>
 155     /// <param name="cur2">Cursor 2 object</param>
 156     /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
 157     virtual public bool CursorEqual(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 158                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_equal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
 159         Eina.Error.RaiseIfUnhandledException();
 160                                         return _ret_var;
 161  }
 162     /// <summary>Compare two cursors</summary>
 163     /// <param name="cur1">Cursor 1 object</param>
 164     /// <param name="cur2">Cursor 2 object</param>
 165     /// <returns>Difference between cursors</returns>
 166     virtual public int CursorCompare(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 167                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_compare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
 168         Eina.Error.RaiseIfUnhandledException();
 169                                         return _ret_var;
 170  }
 171     /// <summary>Copy existing cursor</summary>
 172     /// <param name="dst">Destination cursor</param>
 173     /// <param name="src">Source cursor</param>
 174     virtual public void CursorCopy(Efl.TextCursorCursor dst, Efl.TextCursorCursor src) {
 175                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_copy_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dst, src);
 176         Eina.Error.RaiseIfUnhandledException();
 177                                          }
 178     /// <summary>Advances to the next character</summary>
 179     /// <param name="cur">Cursor object</param>
 180     virtual public void CursorCharNext(Efl.TextCursorCursor cur) {
 181                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 182         Eina.Error.RaiseIfUnhandledException();
 183                          }
 184     /// <summary>Advances to the previous character</summary>
 185     /// <param name="cur">Cursor object</param>
 186     virtual public void CursorCharPrev(Efl.TextCursorCursor cur) {
 187                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 188         Eina.Error.RaiseIfUnhandledException();
 189                          }
 190     /// <summary>Advances to the next grapheme cluster</summary>
 191     /// <param name="cur">Cursor object</param>
 192     virtual public void CursorClusterNext(Efl.TextCursorCursor cur) {
 193                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 194         Eina.Error.RaiseIfUnhandledException();
 195                          }
 196     /// <summary>Advances to the previous grapheme cluster</summary>
 197     /// <param name="cur">Cursor object</param>
 198     virtual public void CursorClusterPrev(Efl.TextCursorCursor cur) {
 199                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 200         Eina.Error.RaiseIfUnhandledException();
 201                          }
 202     /// <summary>Advances to the first character in this paragraph</summary>
 203     /// <param name="cur">Cursor object</param>
 204     virtual public void CursorParagraphCharFirst(Efl.TextCursorCursor cur) {
 205                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 206         Eina.Error.RaiseIfUnhandledException();
 207                          }
 208     /// <summary>Advances to the last character in this paragraph</summary>
 209     /// <param name="cur">Cursor object</param>
 210     virtual public void CursorParagraphCharLast(Efl.TextCursorCursor cur) {
 211                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <summary>Advance to current word start</summary>
 215     /// <param name="cur">Cursor object</param>
 216     virtual public void CursorWordStart(Efl.TextCursorCursor cur) {
 217                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 218         Eina.Error.RaiseIfUnhandledException();
 219                          }
 220     /// <summary>Advance to current word end</summary>
 221     /// <param name="cur">Cursor object</param>
 222     virtual public void CursorWordEnd(Efl.TextCursorCursor cur) {
 223                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 224         Eina.Error.RaiseIfUnhandledException();
 225                          }
 226     /// <summary>Advance to current line first character</summary>
 227     /// <param name="cur">Cursor object</param>
 228     virtual public void CursorLineCharFirst(Efl.TextCursorCursor cur) {
 229                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 230         Eina.Error.RaiseIfUnhandledException();
 231                          }
 232     /// <summary>Advance to current line last character</summary>
 233     /// <param name="cur">Cursor object</param>
 234     virtual public void CursorLineCharLast(Efl.TextCursorCursor cur) {
 235                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 236         Eina.Error.RaiseIfUnhandledException();
 237                          }
 238     /// <summary>Advance to current paragraph first character</summary>
 239     /// <param name="cur">Cursor object</param>
 240     virtual public void CursorParagraphFirst(Efl.TextCursorCursor cur) {
 241                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 242         Eina.Error.RaiseIfUnhandledException();
 243                          }
 244     /// <summary>Advance to current paragraph last character</summary>
 245     /// <param name="cur">Cursor object</param>
 246     virtual public void CursorParagraphLast(Efl.TextCursorCursor cur) {
 247                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 248         Eina.Error.RaiseIfUnhandledException();
 249                          }
 250     /// <summary>Advances to the start of the next text node</summary>
 251     /// <param name="cur">Cursor object</param>
 252     virtual public void CursorParagraphNext(Efl.TextCursorCursor cur) {
 253                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 254         Eina.Error.RaiseIfUnhandledException();
 255                          }
 256     /// <summary>Advances to the end of the previous text node</summary>
 257     /// <param name="cur">Cursor object</param>
 258     virtual public void CursorParagraphPrev(Efl.TextCursorCursor cur) {
 259                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 260         Eina.Error.RaiseIfUnhandledException();
 261                          }
 262     /// <summary>Jump the cursor by the given number of lines</summary>
 263     /// <param name="cur">Cursor object</param>
 264     /// <param name="by">Number of lines</param>
 265     virtual public void CursorLineJumpBy(Efl.TextCursorCursor cur, int by) {
 266                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_jump_by_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, by);
 267         Eina.Error.RaiseIfUnhandledException();
 268                                          }
 269     /// <summary>Set cursor coordinates</summary>
 270     /// <param name="cur">Cursor object</param>
 271     /// <param name="x">X coord to set by.</param>
 272     /// <param name="y">Y coord to set by.</param>
 273     virtual public void SetCursorCoord(Efl.TextCursorCursor cur, int x, int y) {
 274                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
 275         Eina.Error.RaiseIfUnhandledException();
 276                                                          }
 277     /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
 278     /// <param name="cur">Cursor object</param>
 279     /// <param name="x">X coord to set by.</param>
 280     /// <param name="y">Y coord to set by.</param>
 281     virtual public void SetCursorClusterCoord(Efl.TextCursorCursor cur, int x, int y) {
 282                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
 283         Eina.Error.RaiseIfUnhandledException();
 284                                                          }
 285     /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
 286     /// <param name="cur">Cursor object</param>
 287     /// <param name="text">Text to append (UTF-8 format).</param>
 288     /// <returns>Length of the appended text.</returns>
 289     virtual public int CursorTextInsert(Efl.TextCursorCursor cur, System.String text) {
 290                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_text_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, text);
 291         Eina.Error.RaiseIfUnhandledException();
 292                                         return _ret_var;
 293  }
 294     /// <summary>Deletes a single character from position pointed by given cursor.</summary>
 295     /// <param name="cur">Cursor object</param>
 296     virtual public void CursorCharDelete(Efl.TextCursorCursor cur) {
 297                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_delete_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 298         Eina.Error.RaiseIfUnhandledException();
 299                          }
 300     /// <summary>Retrieve the font family and size in use on a given text object.
 301     /// 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.
 302     ///
 303     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 304     /// <param name="font">The font family name or filename.</param>
 305     /// <param name="size">The font size, in points.</param>
 306     virtual public void GetFont(out System.String font, out Efl.Font.Size size) {
 307                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out font, out size);
 308         Eina.Error.RaiseIfUnhandledException();
 309                                          }
 310     /// <summary>Set the font family, filename and size for a given text object.
 311     /// 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.
 312     ///
 313     /// See also <see cref="Efl.ITextFont.GetFont"/>, <see cref="Efl.ITextFont.GetFontSource"/>.</summary>
 314     /// <param name="font">The font family name or filename.</param>
 315     /// <param name="size">The font size, in points.</param>
 316     virtual public void SetFont(System.String font, Efl.Font.Size size) {
 317                                                          Efl.ITextFontConcrete.NativeMethods.efl_text_font_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),font, size);
 318         Eina.Error.RaiseIfUnhandledException();
 319                                          }
 320     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 321     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 322     /// <returns>The font file&apos;s path.</returns>
 323     virtual public System.String GetFontSource() {
 324          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 325         Eina.Error.RaiseIfUnhandledException();
 326         return _ret_var;
 327  }
 328     /// <summary>Set the font (source) file to be used on a given text object.
 329     /// 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.
 330     ///
 331     /// See also <see cref="Efl.ITextFont.GetFont"/>.</summary>
 332     /// <param name="font_source">The font file&apos;s path.</param>
 333     virtual public void SetFontSource(System.String font_source) {
 334                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_source_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),font_source);
 335         Eina.Error.RaiseIfUnhandledException();
 336                          }
 337     /// <summary>Comma-separated list of font fallbacks
 338     /// Will be used in case the primary font isn&apos;t available.</summary>
 339     /// <returns>Font name fallbacks</returns>
 340     virtual public System.String GetFontFallbacks() {
 341          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 342         Eina.Error.RaiseIfUnhandledException();
 343         return _ret_var;
 344  }
 345     /// <summary>Comma-separated list of font fallbacks
 346     /// Will be used in case the primary font isn&apos;t available.</summary>
 347     /// <param name="font_fallbacks">Font name fallbacks</param>
 348     virtual public void SetFontFallbacks(System.String font_fallbacks) {
 349                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_fallbacks_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),font_fallbacks);
 350         Eina.Error.RaiseIfUnhandledException();
 351                          }
 352     /// <summary>Type of weight of the displayed font
 353     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 354     /// <returns>Font weight</returns>
 355     virtual public Efl.TextFontWeight GetFontWeight() {
 356          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 357         Eina.Error.RaiseIfUnhandledException();
 358         return _ret_var;
 359  }
 360     /// <summary>Type of weight of the displayed font
 361     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 362     /// <param name="font_weight">Font weight</param>
 363     virtual public void SetFontWeight(Efl.TextFontWeight font_weight) {
 364                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_weight_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),font_weight);
 365         Eina.Error.RaiseIfUnhandledException();
 366                          }
 367     /// <summary>Type of slant of the displayed font
 368     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 369     /// <returns>Font slant</returns>
 370     virtual public Efl.TextFontSlant GetFontSlant() {
 371          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 372         Eina.Error.RaiseIfUnhandledException();
 373         return _ret_var;
 374  }
 375     /// <summary>Type of slant of the displayed font
 376     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 377     /// <param name="style">Font slant</param>
 378     virtual public void SetFontSlant(Efl.TextFontSlant style) {
 379                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_slant_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),style);
 380         Eina.Error.RaiseIfUnhandledException();
 381                          }
 382     /// <summary>Type of width of the displayed font
 383     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 384     /// <returns>Font width</returns>
 385     virtual public Efl.TextFontWidth GetFontWidth() {
 386          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 387         Eina.Error.RaiseIfUnhandledException();
 388         return _ret_var;
 389  }
 390     /// <summary>Type of width of the displayed font
 391     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 392     /// <param name="width">Font width</param>
 393     virtual public void SetFontWidth(Efl.TextFontWidth width) {
 394                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_width_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),width);
 395         Eina.Error.RaiseIfUnhandledException();
 396                          }
 397     /// <summary>Specific language of the displayed font
 398     /// 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>
 399     /// <returns>Language</returns>
 400     virtual public System.String GetFontLang() {
 401          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 402         Eina.Error.RaiseIfUnhandledException();
 403         return _ret_var;
 404  }
 405     /// <summary>Specific language of the displayed font
 406     /// 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>
 407     /// <param name="lang">Language</param>
 408     virtual public void SetFontLang(System.String lang) {
 409                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_lang_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),lang);
 410         Eina.Error.RaiseIfUnhandledException();
 411                          }
 412     /// <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)
 413     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 414     /// <returns>Scalable</returns>
 415     virtual public Efl.TextFontBitmapScalable GetFontBitmapScalable() {
 416          var _ret_var = Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 417         Eina.Error.RaiseIfUnhandledException();
 418         return _ret_var;
 419  }
 420     /// <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)
 421     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 422     /// <param name="scalable">Scalable</param>
 423     virtual public void SetFontBitmapScalable(Efl.TextFontBitmapScalable scalable) {
 424                                  Efl.ITextFontConcrete.NativeMethods.efl_text_font_bitmap_scalable_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),scalable);
 425         Eina.Error.RaiseIfUnhandledException();
 426                          }
 427     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 428     /// <returns>Ellipsis value</returns>
 429     virtual public double GetEllipsis() {
 430          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 431         Eina.Error.RaiseIfUnhandledException();
 432         return _ret_var;
 433  }
 434     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 435     /// <param name="value">Ellipsis value</param>
 436     virtual public void SetEllipsis(double value) {
 437                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_ellipsis_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 438         Eina.Error.RaiseIfUnhandledException();
 439                          }
 440     /// <summary>Wrap mode for use in the text</summary>
 441     /// <returns>Wrap mode</returns>
 442     virtual public Efl.TextFormatWrap GetWrap() {
 443          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 444         Eina.Error.RaiseIfUnhandledException();
 445         return _ret_var;
 446  }
 447     /// <summary>Wrap mode for use in the text</summary>
 448     /// <param name="wrap">Wrap mode</param>
 449     virtual public void SetWrap(Efl.TextFormatWrap wrap) {
 450                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_wrap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),wrap);
 451         Eina.Error.RaiseIfUnhandledException();
 452                          }
 453     /// <summary>Multiline is enabled or not</summary>
 454     /// <returns><c>true</c> if multiline is enabled, <c>false</c> otherwise</returns>
 455     virtual public bool GetMultiline() {
 456          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 457         Eina.Error.RaiseIfUnhandledException();
 458         return _ret_var;
 459  }
 460     /// <summary>Multiline is enabled or not</summary>
 461     /// <param name="enabled"><c>true</c> if multiline is enabled, <c>false</c> otherwise</param>
 462     virtual public void SetMultiline(bool enabled) {
 463                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_multiline_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),enabled);
 464         Eina.Error.RaiseIfUnhandledException();
 465                          }
 466     /// <summary>Horizontal alignment of text</summary>
 467     /// <returns>Alignment type</returns>
 468     virtual public Efl.TextFormatHorizontalAlignmentAutoType GetHalignAutoType() {
 469          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 470         Eina.Error.RaiseIfUnhandledException();
 471         return _ret_var;
 472  }
 473     /// <summary>Horizontal alignment of text</summary>
 474     /// <param name="value">Alignment type</param>
 475     virtual public void SetHalignAutoType(Efl.TextFormatHorizontalAlignmentAutoType value) {
 476                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_auto_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 477         Eina.Error.RaiseIfUnhandledException();
 478                          }
 479     /// <summary>Horizontal alignment of text</summary>
 480     /// <returns>Horizontal alignment value</returns>
 481     virtual public double GetHalign() {
 482          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 483         Eina.Error.RaiseIfUnhandledException();
 484         return _ret_var;
 485  }
 486     /// <summary>Horizontal alignment of text</summary>
 487     /// <param name="value">Horizontal alignment value</param>
 488     virtual public void SetHalign(double value) {
 489                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_halign_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 490         Eina.Error.RaiseIfUnhandledException();
 491                          }
 492     /// <summary>Vertical alignment of text</summary>
 493     /// <returns>Vertical alignment value</returns>
 494     virtual public double GetValign() {
 495          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 496         Eina.Error.RaiseIfUnhandledException();
 497         return _ret_var;
 498  }
 499     /// <summary>Vertical alignment of text</summary>
 500     /// <param name="value">Vertical alignment value</param>
 501     virtual public void SetValign(double value) {
 502                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_valign_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 503         Eina.Error.RaiseIfUnhandledException();
 504                          }
 505     /// <summary>Minimal line gap (top and bottom) for each line in the text
 506     /// <c>value</c> is absolute size.</summary>
 507     /// <returns>Line gap value</returns>
 508     virtual public double GetLinegap() {
 509          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 510         Eina.Error.RaiseIfUnhandledException();
 511         return _ret_var;
 512  }
 513     /// <summary>Minimal line gap (top and bottom) for each line in the text
 514     /// <c>value</c> is absolute size.</summary>
 515     /// <param name="value">Line gap value</param>
 516     virtual public void SetLinegap(double value) {
 517                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linegap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 518         Eina.Error.RaiseIfUnhandledException();
 519                          }
 520     /// <summary>Relative line gap (top and bottom) for each line in the text
 521     /// The original line gap value is multiplied by <c>value</c>.</summary>
 522     /// <returns>Relative line gap value</returns>
 523     virtual public double GetLinerelgap() {
 524          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 525         Eina.Error.RaiseIfUnhandledException();
 526         return _ret_var;
 527  }
 528     /// <summary>Relative line gap (top and bottom) for each line in the text
 529     /// The original line gap value is multiplied by <c>value</c>.</summary>
 530     /// <param name="value">Relative line gap value</param>
 531     virtual public void SetLinerelgap(double value) {
 532                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_linerelgap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 533         Eina.Error.RaiseIfUnhandledException();
 534                          }
 535     /// <summary>Tabstops value</summary>
 536     /// <returns>Tapstops value</returns>
 537     virtual public int GetTabstops() {
 538          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 539         Eina.Error.RaiseIfUnhandledException();
 540         return _ret_var;
 541  }
 542     /// <summary>Tabstops value</summary>
 543     /// <param name="value">Tapstops value</param>
 544     virtual public void SetTabstops(int value) {
 545                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_tabstops_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 546         Eina.Error.RaiseIfUnhandledException();
 547                          }
 548     /// <summary>Whether text is a password</summary>
 549     /// <returns><c>true</c> if the text is a password, <c>false</c> otherwise</returns>
 550     virtual public bool GetPassword() {
 551          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_password_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 552         Eina.Error.RaiseIfUnhandledException();
 553         return _ret_var;
 554  }
 555     /// <summary>Whether text is a password</summary>
 556     /// <param name="enabled"><c>true</c> if the text is a password, <c>false</c> otherwise</param>
 557     virtual public void SetPassword(bool enabled) {
 558                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_password_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),enabled);
 559         Eina.Error.RaiseIfUnhandledException();
 560                          }
 561     /// <summary>The character used to replace characters that can&apos;t be displayed
 562     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 563     /// <returns>Replacement character</returns>
 564     virtual public System.String GetReplacementChar() {
 565          var _ret_var = Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 566         Eina.Error.RaiseIfUnhandledException();
 567         return _ret_var;
 568  }
 569     /// <summary>The character used to replace characters that can&apos;t be displayed
 570     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
 571     /// <param name="repch">Replacement character</param>
 572     virtual public void SetReplacementChar(System.String repch) {
 573                                  Efl.ITextFormatConcrete.NativeMethods.efl_text_replacement_char_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),repch);
 574         Eina.Error.RaiseIfUnhandledException();
 575                          }
 576     /// <summary>Markup property</summary>
 577     /// <returns>The markup-text representation set to this text.</returns>
 578     virtual public System.String GetMarkup() {
 579          var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 580         Eina.Error.RaiseIfUnhandledException();
 581         return _ret_var;
 582  }
 583     /// <summary>Markup property</summary>
 584     /// <param name="markup">The markup-text representation set to this text.</param>
 585     virtual public void SetMarkup(System.String markup) {
 586                                  Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),markup);
 587         Eina.Error.RaiseIfUnhandledException();
 588                          }
 589     /// <summary>Markup of a given range in the text</summary>
 590     /// <param name="start">Start of the markup region</param>
 591     /// <param name="end">End of markup region</param>
 592     /// <returns>The markup-text representation set to this text of a given range</returns>
 593     virtual public System.String GetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end) {
 594                                                          var _ret_var = Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end);
 595         Eina.Error.RaiseIfUnhandledException();
 596                                         return _ret_var;
 597  }
 598     /// <summary>Markup of a given range in the text</summary>
 599     /// <param name="start">Start of the markup region</param>
 600     /// <param name="end">End of markup region</param>
 601     /// <param name="markup">The markup-text representation set to this text of a given range</param>
 602     virtual public void SetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup) {
 603                                                                                  Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end, markup);
 604         Eina.Error.RaiseIfUnhandledException();
 605                                                          }
 606     /// <summary>Inserts a markup text to the text object in a given cursor position</summary>
 607     /// <param name="cur">Cursor position to insert markup</param>
 608     /// <param name="markup">The markup text to insert</param>
 609     virtual public void CursorMarkupInsert(Efl.TextCursorCursor cur, System.String markup) {
 610                                                          Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, markup);
 611         Eina.Error.RaiseIfUnhandledException();
 612                                          }
 613     /// <summary>Color of text, excluding style</summary>
 614     /// <param name="r">Red component</param>
 615     /// <param name="g">Green component</param>
 616     /// <param name="b">Blue component</param>
 617     /// <param name="a">Alpha component</param>
 618     virtual public void GetNormalColor(out byte r, out byte g, out byte b, out byte a) {
 619                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 620         Eina.Error.RaiseIfUnhandledException();
 621                                                                          }
 622     /// <summary>Color of text, excluding style</summary>
 623     /// <param name="r">Red component</param>
 624     /// <param name="g">Green component</param>
 625     /// <param name="b">Blue component</param>
 626     /// <param name="a">Alpha component</param>
 627     virtual public void SetNormalColor(byte r, byte g, byte b, byte a) {
 628                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_normal_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 629         Eina.Error.RaiseIfUnhandledException();
 630                                                                          }
 631     /// <summary>Enable or disable backing type</summary>
 632     /// <returns>Backing type</returns>
 633     virtual public Efl.TextStyleBackingType GetBackingType() {
 634          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 635         Eina.Error.RaiseIfUnhandledException();
 636         return _ret_var;
 637  }
 638     /// <summary>Enable or disable backing type</summary>
 639     /// <param name="type">Backing type</param>
 640     virtual public void SetBackingType(Efl.TextStyleBackingType type) {
 641                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
 642         Eina.Error.RaiseIfUnhandledException();
 643                          }
 644     /// <summary>Backing color</summary>
 645     /// <param name="r">Red component</param>
 646     /// <param name="g">Green component</param>
 647     /// <param name="b">Blue component</param>
 648     /// <param name="a">Alpha component</param>
 649     virtual public void GetBackingColor(out byte r, out byte g, out byte b, out byte a) {
 650                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 651         Eina.Error.RaiseIfUnhandledException();
 652                                                                          }
 653     /// <summary>Backing color</summary>
 654     /// <param name="r">Red component</param>
 655     /// <param name="g">Green component</param>
 656     /// <param name="b">Blue component</param>
 657     /// <param name="a">Alpha component</param>
 658     virtual public void SetBackingColor(byte r, byte g, byte b, byte a) {
 659                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_backing_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 660         Eina.Error.RaiseIfUnhandledException();
 661                                                                          }
 662     /// <summary>Sets an underline style on the text</summary>
 663     /// <returns>Underline type</returns>
 664     virtual public Efl.TextStyleUnderlineType GetUnderlineType() {
 665          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 666         Eina.Error.RaiseIfUnhandledException();
 667         return _ret_var;
 668  }
 669     /// <summary>Sets an underline style on the text</summary>
 670     /// <param name="type">Underline type</param>
 671     virtual public void SetUnderlineType(Efl.TextStyleUnderlineType type) {
 672                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
 673         Eina.Error.RaiseIfUnhandledException();
 674                          }
 675     /// <summary>Color of normal underline style</summary>
 676     /// <param name="r">Red component</param>
 677     /// <param name="g">Green component</param>
 678     /// <param name="b">Blue component</param>
 679     /// <param name="a">Alpha component</param>
 680     virtual public void GetUnderlineColor(out byte r, out byte g, out byte b, out byte a) {
 681                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 682         Eina.Error.RaiseIfUnhandledException();
 683                                                                          }
 684     /// <summary>Color of normal underline style</summary>
 685     /// <param name="r">Red component</param>
 686     /// <param name="g">Green component</param>
 687     /// <param name="b">Blue component</param>
 688     /// <param name="a">Alpha component</param>
 689     virtual public void SetUnderlineColor(byte r, byte g, byte b, byte a) {
 690                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 691         Eina.Error.RaiseIfUnhandledException();
 692                                                                          }
 693     /// <summary>Height of underline style</summary>
 694     /// <returns>Height</returns>
 695     virtual public double GetUnderlineHeight() {
 696          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 697         Eina.Error.RaiseIfUnhandledException();
 698         return _ret_var;
 699  }
 700     /// <summary>Height of underline style</summary>
 701     /// <param name="height">Height</param>
 702     virtual public void SetUnderlineHeight(double height) {
 703                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_height_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),height);
 704         Eina.Error.RaiseIfUnhandledException();
 705                          }
 706     /// <summary>Color of dashed underline style</summary>
 707     /// <param name="r">Red component</param>
 708     /// <param name="g">Green component</param>
 709     /// <param name="b">Blue component</param>
 710     /// <param name="a">Alpha component</param>
 711     virtual public void GetUnderlineDashedColor(out byte r, out byte g, out byte b, out byte a) {
 712                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 713         Eina.Error.RaiseIfUnhandledException();
 714                                                                          }
 715     /// <summary>Color of dashed underline style</summary>
 716     /// <param name="r">Red component</param>
 717     /// <param name="g">Green component</param>
 718     /// <param name="b">Blue component</param>
 719     /// <param name="a">Alpha component</param>
 720     virtual public void SetUnderlineDashedColor(byte r, byte g, byte b, byte a) {
 721                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 722         Eina.Error.RaiseIfUnhandledException();
 723                                                                          }
 724     /// <summary>Width of dashed underline style</summary>
 725     /// <returns>Width</returns>
 726     virtual public int GetUnderlineDashedWidth() {
 727          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 728         Eina.Error.RaiseIfUnhandledException();
 729         return _ret_var;
 730  }
 731     /// <summary>Width of dashed underline style</summary>
 732     /// <param name="width">Width</param>
 733     virtual public void SetUnderlineDashedWidth(int width) {
 734                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_width_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),width);
 735         Eina.Error.RaiseIfUnhandledException();
 736                          }
 737     /// <summary>Gap of dashed underline style</summary>
 738     /// <returns>Gap</returns>
 739     virtual public int GetUnderlineDashedGap() {
 740          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 741         Eina.Error.RaiseIfUnhandledException();
 742         return _ret_var;
 743  }
 744     /// <summary>Gap of dashed underline style</summary>
 745     /// <param name="gap">Gap</param>
 746     virtual public void SetUnderlineDashedGap(int gap) {
 747                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_underline_dashed_gap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),gap);
 748         Eina.Error.RaiseIfUnhandledException();
 749                          }
 750     /// <summary>Color of underline2 style</summary>
 751     /// <param name="r">Red component</param>
 752     /// <param name="g">Green component</param>
 753     /// <param name="b">Blue component</param>
 754     /// <param name="a">Alpha component</param>
 755     virtual public void GetUnderline2Color(out byte r, out byte g, out byte b, out byte a) {
 756                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 757         Eina.Error.RaiseIfUnhandledException();
 758                                                                          }
 759     /// <summary>Color of underline2 style</summary>
 760     /// <param name="r">Red component</param>
 761     /// <param name="g">Green component</param>
 762     /// <param name="b">Blue component</param>
 763     /// <param name="a">Alpha component</param>
 764     virtual public void SetUnderline2Color(byte r, byte g, byte b, byte a) {
 765                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_underline2_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 766         Eina.Error.RaiseIfUnhandledException();
 767                                                                          }
 768     /// <summary>Type of strikethrough style</summary>
 769     /// <returns>Strikethrough type</returns>
 770     virtual public Efl.TextStyleStrikethroughType GetStrikethroughType() {
 771          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 772         Eina.Error.RaiseIfUnhandledException();
 773         return _ret_var;
 774  }
 775     /// <summary>Type of strikethrough style</summary>
 776     /// <param name="type">Strikethrough type</param>
 777     virtual public void SetStrikethroughType(Efl.TextStyleStrikethroughType type) {
 778                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
 779         Eina.Error.RaiseIfUnhandledException();
 780                          }
 781     /// <summary>Color of strikethrough_style</summary>
 782     /// <param name="r">Red component</param>
 783     /// <param name="g">Green component</param>
 784     /// <param name="b">Blue component</param>
 785     /// <param name="a">Alpha component</param>
 786     virtual public void GetStrikethroughColor(out byte r, out byte g, out byte b, out byte a) {
 787                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 788         Eina.Error.RaiseIfUnhandledException();
 789                                                                          }
 790     /// <summary>Color of strikethrough_style</summary>
 791     /// <param name="r">Red component</param>
 792     /// <param name="g">Green component</param>
 793     /// <param name="b">Blue component</param>
 794     /// <param name="a">Alpha component</param>
 795     virtual public void SetStrikethroughColor(byte r, byte g, byte b, byte a) {
 796                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_strikethrough_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 797         Eina.Error.RaiseIfUnhandledException();
 798                                                                          }
 799     /// <summary>Type of effect used for the displayed text</summary>
 800     /// <returns>Effect type</returns>
 801     virtual public Efl.TextStyleEffectType GetEffectType() {
 802          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 803         Eina.Error.RaiseIfUnhandledException();
 804         return _ret_var;
 805  }
 806     /// <summary>Type of effect used for the displayed text</summary>
 807     /// <param name="type">Effect type</param>
 808     virtual public void SetEffectType(Efl.TextStyleEffectType type) {
 809                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_effect_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
 810         Eina.Error.RaiseIfUnhandledException();
 811                          }
 812     /// <summary>Color of outline effect</summary>
 813     /// <param name="r">Red component</param>
 814     /// <param name="g">Green component</param>
 815     /// <param name="b">Blue component</param>
 816     /// <param name="a">Alpha component</param>
 817     virtual public void GetOutlineColor(out byte r, out byte g, out byte b, out byte a) {
 818                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 819         Eina.Error.RaiseIfUnhandledException();
 820                                                                          }
 821     /// <summary>Color of outline effect</summary>
 822     /// <param name="r">Red component</param>
 823     /// <param name="g">Green component</param>
 824     /// <param name="b">Blue component</param>
 825     /// <param name="a">Alpha component</param>
 826     virtual public void SetOutlineColor(byte r, byte g, byte b, byte a) {
 827                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_outline_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 828         Eina.Error.RaiseIfUnhandledException();
 829                                                                          }
 830     /// <summary>Direction of shadow effect</summary>
 831     /// <returns>Shadow direction</returns>
 832     virtual public Efl.TextStyleShadowDirection GetShadowDirection() {
 833          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 834         Eina.Error.RaiseIfUnhandledException();
 835         return _ret_var;
 836  }
 837     /// <summary>Direction of shadow effect</summary>
 838     /// <param name="type">Shadow direction</param>
 839     virtual public void SetShadowDirection(Efl.TextStyleShadowDirection type) {
 840                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_direction_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),type);
 841         Eina.Error.RaiseIfUnhandledException();
 842                          }
 843     /// <summary>Color of shadow effect</summary>
 844     /// <param name="r">Red component</param>
 845     /// <param name="g">Green component</param>
 846     /// <param name="b">Blue component</param>
 847     /// <param name="a">Alpha component</param>
 848     virtual public void GetShadowColor(out byte r, out byte g, out byte b, out byte a) {
 849                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 850         Eina.Error.RaiseIfUnhandledException();
 851                                                                          }
 852     /// <summary>Color of shadow effect</summary>
 853     /// <param name="r">Red component</param>
 854     /// <param name="g">Green component</param>
 855     /// <param name="b">Blue component</param>
 856     /// <param name="a">Alpha component</param>
 857     virtual public void SetShadowColor(byte r, byte g, byte b, byte a) {
 858                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_shadow_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 859         Eina.Error.RaiseIfUnhandledException();
 860                                                                          }
 861     /// <summary>Color of glow effect</summary>
 862     /// <param name="r">Red component</param>
 863     /// <param name="g">Green component</param>
 864     /// <param name="b">Blue component</param>
 865     /// <param name="a">Alpha component</param>
 866     virtual public void GetGlowColor(out byte r, out byte g, out byte b, out byte a) {
 867                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 868         Eina.Error.RaiseIfUnhandledException();
 869                                                                          }
 870     /// <summary>Color of glow effect</summary>
 871     /// <param name="r">Red component</param>
 872     /// <param name="g">Green component</param>
 873     /// <param name="b">Blue component</param>
 874     /// <param name="a">Alpha component</param>
 875     virtual public void SetGlowColor(byte r, byte g, byte b, byte a) {
 876                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 877         Eina.Error.RaiseIfUnhandledException();
 878                                                                          }
 879     /// <summary>Second color of the glow effect</summary>
 880     /// <param name="r">Red component</param>
 881     /// <param name="g">Green component</param>
 882     /// <param name="b">Blue component</param>
 883     /// <param name="a">Alpha component</param>
 884     virtual public void GetGlow2Color(out byte r, out byte g, out byte b, out byte a) {
 885                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 886         Eina.Error.RaiseIfUnhandledException();
 887                                                                          }
 888     /// <summary>Second color of the glow effect</summary>
 889     /// <param name="r">Red component</param>
 890     /// <param name="g">Green component</param>
 891     /// <param name="b">Blue component</param>
 892     /// <param name="a">Alpha component</param>
 893     virtual public void SetGlow2Color(byte r, byte g, byte b, byte a) {
 894                                                                                                          Efl.ITextStyleConcrete.NativeMethods.efl_text_glow2_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 895         Eina.Error.RaiseIfUnhandledException();
 896                                                                          }
 897     /// <summary>Program that applies a special filter
 898     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 899     /// <returns>Filter code</returns>
 900     virtual public System.String GetGfxFilter() {
 901          var _ret_var = Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 902         Eina.Error.RaiseIfUnhandledException();
 903         return _ret_var;
 904  }
 905     /// <summary>Program that applies a special filter
 906     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
 907     /// <param name="code">Filter code</param>
 908     virtual public void SetGfxFilter(System.String code) {
 909                                  Efl.ITextStyleConcrete.NativeMethods.efl_text_gfx_filter_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),code);
 910         Eina.Error.RaiseIfUnhandledException();
 911                          }
 912     /// <summary>Sizing policy for text parts.
 913     /// This will determine whether to consider height or width constraints, if text-specific behaviors occur (such as ellipsis, line-wrapping etc.</summary>
 914     public Efl.Canvas.LayoutPartTextExpand TextExpand {
 915         get { return GetTextExpand(); }
 916         set { SetTextExpand(value); }
 917     }
 918     /// <summary>Get the font file&apos;s path which is being used on a given text object.
 919     /// See <see cref="Efl.ITextFont.GetFont"/> for more details.</summary>
 920     /// <value>The font file&apos;s path.</value>
 921     public System.String FontSource {
 922         get { return GetFontSource(); }
 923         set { SetFontSource(value); }
 924     }
 925     /// <summary>Comma-separated list of font fallbacks
 926     /// Will be used in case the primary font isn&apos;t available.</summary>
 927     /// <value>Font name fallbacks</value>
 928     public System.String FontFallbacks {
 929         get { return GetFontFallbacks(); }
 930         set { SetFontFallbacks(value); }
 931     }
 932     /// <summary>Type of weight of the displayed font
 933     /// Default is <see cref="Efl.TextFontWeight.Normal"/>.</summary>
 934     /// <value>Font weight</value>
 935     public Efl.TextFontWeight FontWeight {
 936         get { return GetFontWeight(); }
 937         set { SetFontWeight(value); }
 938     }
 939     /// <summary>Type of slant of the displayed font
 940     /// Default is <see cref="Efl.TextFontSlant.Normal"/>.</summary>
 941     /// <value>Font slant</value>
 942     public Efl.TextFontSlant FontSlant {
 943         get { return GetFontSlant(); }
 944         set { SetFontSlant(value); }
 945     }
 946     /// <summary>Type of width of the displayed font
 947     /// Default is <see cref="Efl.TextFontWidth.Normal"/>.</summary>
 948     /// <value>Font width</value>
 949     public Efl.TextFontWidth FontWidth {
 950         get { return GetFontWidth(); }
 951         set { SetFontWidth(value); }
 952     }
 953     /// <summary>Specific language of the displayed font
 954     /// 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>
 955     /// <value>Language</value>
 956     public System.String FontLang {
 957         get { return GetFontLang(); }
 958         set { SetFontLang(value); }
 959     }
 960     /// <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)
 961     /// Default is <see cref="Efl.TextFontBitmapScalable.None"/>.</summary>
 962     /// <value>Scalable</value>
 963     public Efl.TextFontBitmapScalable FontBitmapScalable {
 964         get { return GetFontBitmapScalable(); }
 965         set { SetFontBitmapScalable(value); }
 966     }
 967     /// <summary>Ellipsis value (number from -1.0 to 1.0)</summary>
 968     /// <value>Ellipsis value</value>
 969     public double Ellipsis {
 970         get { return GetEllipsis(); }
 971         set { SetEllipsis(value); }
 972     }
 973     /// <summary>Wrap mode for use in the text</summary>
 974     /// <value>Wrap mode</value>
 975     public Efl.TextFormatWrap Wrap {
 976         get { return GetWrap(); }
 977         set { SetWrap(value); }
 978     }
 979     /// <summary>Multiline is enabled or not</summary>
 980     /// <value><c>true</c> if multiline is enabled, <c>false</c> otherwise</value>
 981     public bool Multiline {
 982         get { return GetMultiline(); }
 983         set { SetMultiline(value); }
 984     }
 985     /// <summary>Horizontal alignment of text</summary>
 986     /// <value>Alignment type</value>
 987     public Efl.TextFormatHorizontalAlignmentAutoType HalignAutoType {
 988         get { return GetHalignAutoType(); }
 989         set { SetHalignAutoType(value); }
 990     }
 991     /// <summary>Horizontal alignment of text</summary>
 992     /// <value>Horizontal alignment value</value>
 993     public double Halign {
 994         get { return GetHalign(); }
 995         set { SetHalign(value); }
 996     }
 997     /// <summary>Vertical alignment of text</summary>
 998     /// <value>Vertical alignment value</value>
 999     public double Valign {
1000         get { return GetValign(); }
1001         set { SetValign(value); }
1002     }
1003     /// <summary>Minimal line gap (top and bottom) for each line in the text
1004     /// <c>value</c> is absolute size.</summary>
1005     /// <value>Line gap value</value>
1006     public double Linegap {
1007         get { return GetLinegap(); }
1008         set { SetLinegap(value); }
1009     }
1010     /// <summary>Relative line gap (top and bottom) for each line in the text
1011     /// The original line gap value is multiplied by <c>value</c>.</summary>
1012     /// <value>Relative line gap value</value>
1013     public double Linerelgap {
1014         get { return GetLinerelgap(); }
1015         set { SetLinerelgap(value); }
1016     }
1017     /// <summary>Tabstops value</summary>
1018     /// <value>Tapstops value</value>
1019     public int Tabstops {
1020         get { return GetTabstops(); }
1021         set { SetTabstops(value); }
1022     }
1023     /// <summary>Whether text is a password</summary>
1024     /// <value><c>true</c> if the text is a password, <c>false</c> otherwise</value>
1025     public bool Password {
1026         get { return GetPassword(); }
1027         set { SetPassword(value); }
1028     }
1029     /// <summary>The character used to replace characters that can&apos;t be displayed
1030     /// Currently only used to replace characters if <see cref="Efl.ITextFormat.Password"/> is enabled.</summary>
1031     /// <value>Replacement character</value>
1032     public System.String ReplacementChar {
1033         get { return GetReplacementChar(); }
1034         set { SetReplacementChar(value); }
1035     }
1036     /// <summary>Markup property</summary>
1037     /// <value>The markup-text representation set to this text.</value>
1038     public System.String Markup {
1039         get { return GetMarkup(); }
1040         set { SetMarkup(value); }
1041     }
1042     /// <summary>Enable or disable backing type</summary>
1043     /// <value>Backing type</value>
1044     public Efl.TextStyleBackingType BackingType {
1045         get { return GetBackingType(); }
1046         set { SetBackingType(value); }
1047     }
1048     /// <summary>Sets an underline style on the text</summary>
1049     /// <value>Underline type</value>
1050     public Efl.TextStyleUnderlineType UnderlineType {
1051         get { return GetUnderlineType(); }
1052         set { SetUnderlineType(value); }
1053     }
1054     /// <summary>Height of underline style</summary>
1055     /// <value>Height</value>
1056     public double UnderlineHeight {
1057         get { return GetUnderlineHeight(); }
1058         set { SetUnderlineHeight(value); }
1059     }
1060     /// <summary>Width of dashed underline style</summary>
1061     /// <value>Width</value>
1062     public int UnderlineDashedWidth {
1063         get { return GetUnderlineDashedWidth(); }
1064         set { SetUnderlineDashedWidth(value); }
1065     }
1066     /// <summary>Gap of dashed underline style</summary>
1067     /// <value>Gap</value>
1068     public int UnderlineDashedGap {
1069         get { return GetUnderlineDashedGap(); }
1070         set { SetUnderlineDashedGap(value); }
1071     }
1072     /// <summary>Type of strikethrough style</summary>
1073     /// <value>Strikethrough type</value>
1074     public Efl.TextStyleStrikethroughType StrikethroughType {
1075         get { return GetStrikethroughType(); }
1076         set { SetStrikethroughType(value); }
1077     }
1078     /// <summary>Type of effect used for the displayed text</summary>
1079     /// <value>Effect type</value>
1080     public Efl.TextStyleEffectType EffectType {
1081         get { return GetEffectType(); }
1082         set { SetEffectType(value); }
1083     }
1084     /// <summary>Direction of shadow effect</summary>
1085     /// <value>Shadow direction</value>
1086     public Efl.TextStyleShadowDirection ShadowDirection {
1087         get { return GetShadowDirection(); }
1088         set { SetShadowDirection(value); }
1089     }
1090     /// <summary>Program that applies a special filter
1091     /// See <see cref="Efl.Gfx.IFilter"/>.</summary>
1092     /// <value>Filter code</value>
1093     public System.String GfxFilter {
1094         get { return GetGfxFilter(); }
1095         set { SetGfxFilter(value); }
1096     }
1097     private static IntPtr GetEflClassStatic()
1098     {
1099         return Efl.Canvas.LayoutPartText.efl_canvas_layout_part_text_class_get();
1100     }
1101     /// <summary>Wrapper for native methods and virtual method delegates.
1102     /// For internal use by generated code only.</summary>
1103     public new class NativeMethods : Efl.Canvas.LayoutPart.NativeMethods
1104     {
1105         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
1106         /// <summary>Gets the list of Eo operations to override.</summary>
1107         /// <returns>The list of Eo operations to be overload.</returns>
1108         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1109         {
1110             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1111             var methods = Efl.Eo.Globals.GetUserMethods(type);
1112
1113             if (efl_canvas_layout_part_text_expand_get_static_delegate == null)
1114             {
1115                 efl_canvas_layout_part_text_expand_get_static_delegate = new efl_canvas_layout_part_text_expand_get_delegate(text_expand_get);
1116             }
1117
1118             if (methods.FirstOrDefault(m => m.Name == "GetTextExpand") != null)
1119             {
1120                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_layout_part_text_expand_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_expand_get_static_delegate) });
1121             }
1122
1123             if (efl_canvas_layout_part_text_expand_set_static_delegate == null)
1124             {
1125                 efl_canvas_layout_part_text_expand_set_static_delegate = new efl_canvas_layout_part_text_expand_set_delegate(text_expand_set);
1126             }
1127
1128             if (methods.FirstOrDefault(m => m.Name == "SetTextExpand") != null)
1129             {
1130                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_layout_part_text_expand_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_layout_part_text_expand_set_static_delegate) });
1131             }
1132
1133             if (efl_text_get_static_delegate == null)
1134             {
1135                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
1136             }
1137
1138             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
1139             {
1140                 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) });
1141             }
1142
1143             if (efl_text_set_static_delegate == null)
1144             {
1145                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
1146             }
1147
1148             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
1149             {
1150                 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) });
1151             }
1152
1153             if (efl_text_cursor_get_static_delegate == null)
1154             {
1155                 efl_text_cursor_get_static_delegate = new efl_text_cursor_get_delegate(text_cursor_get);
1156             }
1157
1158             if (methods.FirstOrDefault(m => m.Name == "GetTextCursor") != null)
1159             {
1160                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_get_static_delegate) });
1161             }
1162
1163             if (efl_text_cursor_position_get_static_delegate == null)
1164             {
1165                 efl_text_cursor_position_get_static_delegate = new efl_text_cursor_position_get_delegate(cursor_position_get);
1166             }
1167
1168             if (methods.FirstOrDefault(m => m.Name == "GetCursorPosition") != null)
1169             {
1170                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_position_get_static_delegate) });
1171             }
1172
1173             if (efl_text_cursor_position_set_static_delegate == null)
1174             {
1175                 efl_text_cursor_position_set_static_delegate = new efl_text_cursor_position_set_delegate(cursor_position_set);
1176             }
1177
1178             if (methods.FirstOrDefault(m => m.Name == "SetCursorPosition") != null)
1179             {
1180                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_position_set_static_delegate) });
1181             }
1182
1183             if (efl_text_cursor_content_get_static_delegate == null)
1184             {
1185                 efl_text_cursor_content_get_static_delegate = new efl_text_cursor_content_get_delegate(cursor_content_get);
1186             }
1187
1188             if (methods.FirstOrDefault(m => m.Name == "GetCursorContent") != null)
1189             {
1190                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_content_get_static_delegate) });
1191             }
1192
1193             if (efl_text_cursor_geometry_get_static_delegate == null)
1194             {
1195                 efl_text_cursor_geometry_get_static_delegate = new efl_text_cursor_geometry_get_delegate(cursor_geometry_get);
1196             }
1197
1198             if (methods.FirstOrDefault(m => m.Name == "GetCursorGeometry") != null)
1199             {
1200                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_geometry_get_static_delegate) });
1201             }
1202
1203             if (efl_text_cursor_new_static_delegate == null)
1204             {
1205                 efl_text_cursor_new_static_delegate = new efl_text_cursor_new_delegate(cursor_new);
1206             }
1207
1208             if (methods.FirstOrDefault(m => m.Name == "NewCursor") != null)
1209             {
1210                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_new"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_new_static_delegate) });
1211             }
1212
1213             if (efl_text_cursor_free_static_delegate == null)
1214             {
1215                 efl_text_cursor_free_static_delegate = new efl_text_cursor_free_delegate(cursor_free);
1216             }
1217
1218             if (methods.FirstOrDefault(m => m.Name == "CursorFree") != null)
1219             {
1220                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_free"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_free_static_delegate) });
1221             }
1222
1223             if (efl_text_cursor_equal_static_delegate == null)
1224             {
1225                 efl_text_cursor_equal_static_delegate = new efl_text_cursor_equal_delegate(cursor_equal);
1226             }
1227
1228             if (methods.FirstOrDefault(m => m.Name == "CursorEqual") != null)
1229             {
1230                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_equal"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_equal_static_delegate) });
1231             }
1232
1233             if (efl_text_cursor_compare_static_delegate == null)
1234             {
1235                 efl_text_cursor_compare_static_delegate = new efl_text_cursor_compare_delegate(cursor_compare);
1236             }
1237
1238             if (methods.FirstOrDefault(m => m.Name == "CursorCompare") != null)
1239             {
1240                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_compare"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_compare_static_delegate) });
1241             }
1242
1243             if (efl_text_cursor_copy_static_delegate == null)
1244             {
1245                 efl_text_cursor_copy_static_delegate = new efl_text_cursor_copy_delegate(cursor_copy);
1246             }
1247
1248             if (methods.FirstOrDefault(m => m.Name == "CursorCopy") != null)
1249             {
1250                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_copy"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_copy_static_delegate) });
1251             }
1252
1253             if (efl_text_cursor_char_next_static_delegate == null)
1254             {
1255                 efl_text_cursor_char_next_static_delegate = new efl_text_cursor_char_next_delegate(cursor_char_next);
1256             }
1257
1258             if (methods.FirstOrDefault(m => m.Name == "CursorCharNext") != null)
1259             {
1260                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_next_static_delegate) });
1261             }
1262
1263             if (efl_text_cursor_char_prev_static_delegate == null)
1264             {
1265                 efl_text_cursor_char_prev_static_delegate = new efl_text_cursor_char_prev_delegate(cursor_char_prev);
1266             }
1267
1268             if (methods.FirstOrDefault(m => m.Name == "CursorCharPrev") != null)
1269             {
1270                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_prev_static_delegate) });
1271             }
1272
1273             if (efl_text_cursor_cluster_next_static_delegate == null)
1274             {
1275                 efl_text_cursor_cluster_next_static_delegate = new efl_text_cursor_cluster_next_delegate(cursor_cluster_next);
1276             }
1277
1278             if (methods.FirstOrDefault(m => m.Name == "CursorClusterNext") != null)
1279             {
1280                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_next_static_delegate) });
1281             }
1282
1283             if (efl_text_cursor_cluster_prev_static_delegate == null)
1284             {
1285                 efl_text_cursor_cluster_prev_static_delegate = new efl_text_cursor_cluster_prev_delegate(cursor_cluster_prev);
1286             }
1287
1288             if (methods.FirstOrDefault(m => m.Name == "CursorClusterPrev") != null)
1289             {
1290                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_prev_static_delegate) });
1291             }
1292
1293             if (efl_text_cursor_paragraph_char_first_static_delegate == null)
1294             {
1295                 efl_text_cursor_paragraph_char_first_static_delegate = new efl_text_cursor_paragraph_char_first_delegate(cursor_paragraph_char_first);
1296             }
1297
1298             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharFirst") != null)
1299             {
1300                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_char_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_char_first_static_delegate) });
1301             }
1302
1303             if (efl_text_cursor_paragraph_char_last_static_delegate == null)
1304             {
1305                 efl_text_cursor_paragraph_char_last_static_delegate = new efl_text_cursor_paragraph_char_last_delegate(cursor_paragraph_char_last);
1306             }
1307
1308             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharLast") != null)
1309             {
1310                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_char_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_char_last_static_delegate) });
1311             }
1312
1313             if (efl_text_cursor_word_start_static_delegate == null)
1314             {
1315                 efl_text_cursor_word_start_static_delegate = new efl_text_cursor_word_start_delegate(cursor_word_start);
1316             }
1317
1318             if (methods.FirstOrDefault(m => m.Name == "CursorWordStart") != null)
1319             {
1320                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_word_start"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_word_start_static_delegate) });
1321             }
1322
1323             if (efl_text_cursor_word_end_static_delegate == null)
1324             {
1325                 efl_text_cursor_word_end_static_delegate = new efl_text_cursor_word_end_delegate(cursor_word_end);
1326             }
1327
1328             if (methods.FirstOrDefault(m => m.Name == "CursorWordEnd") != null)
1329             {
1330                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_word_end"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_word_end_static_delegate) });
1331             }
1332
1333             if (efl_text_cursor_line_char_first_static_delegate == null)
1334             {
1335                 efl_text_cursor_line_char_first_static_delegate = new efl_text_cursor_line_char_first_delegate(cursor_line_char_first);
1336             }
1337
1338             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharFirst") != null)
1339             {
1340                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_char_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_char_first_static_delegate) });
1341             }
1342
1343             if (efl_text_cursor_line_char_last_static_delegate == null)
1344             {
1345                 efl_text_cursor_line_char_last_static_delegate = new efl_text_cursor_line_char_last_delegate(cursor_line_char_last);
1346             }
1347
1348             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharLast") != null)
1349             {
1350                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_char_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_char_last_static_delegate) });
1351             }
1352
1353             if (efl_text_cursor_paragraph_first_static_delegate == null)
1354             {
1355                 efl_text_cursor_paragraph_first_static_delegate = new efl_text_cursor_paragraph_first_delegate(cursor_paragraph_first);
1356             }
1357
1358             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphFirst") != null)
1359             {
1360                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_first_static_delegate) });
1361             }
1362
1363             if (efl_text_cursor_paragraph_last_static_delegate == null)
1364             {
1365                 efl_text_cursor_paragraph_last_static_delegate = new efl_text_cursor_paragraph_last_delegate(cursor_paragraph_last);
1366             }
1367
1368             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphLast") != null)
1369             {
1370                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_last_static_delegate) });
1371             }
1372
1373             if (efl_text_cursor_paragraph_next_static_delegate == null)
1374             {
1375                 efl_text_cursor_paragraph_next_static_delegate = new efl_text_cursor_paragraph_next_delegate(cursor_paragraph_next);
1376             }
1377
1378             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphNext") != null)
1379             {
1380                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_next_static_delegate) });
1381             }
1382
1383             if (efl_text_cursor_paragraph_prev_static_delegate == null)
1384             {
1385                 efl_text_cursor_paragraph_prev_static_delegate = new efl_text_cursor_paragraph_prev_delegate(cursor_paragraph_prev);
1386             }
1387
1388             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphPrev") != null)
1389             {
1390                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_prev_static_delegate) });
1391             }
1392
1393             if (efl_text_cursor_line_jump_by_static_delegate == null)
1394             {
1395                 efl_text_cursor_line_jump_by_static_delegate = new efl_text_cursor_line_jump_by_delegate(cursor_line_jump_by);
1396             }
1397
1398             if (methods.FirstOrDefault(m => m.Name == "CursorLineJumpBy") != null)
1399             {
1400                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_jump_by"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_jump_by_static_delegate) });
1401             }
1402
1403             if (efl_text_cursor_coord_set_static_delegate == null)
1404             {
1405                 efl_text_cursor_coord_set_static_delegate = new efl_text_cursor_coord_set_delegate(cursor_coord_set);
1406             }
1407
1408             if (methods.FirstOrDefault(m => m.Name == "SetCursorCoord") != null)
1409             {
1410                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_coord_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_coord_set_static_delegate) });
1411             }
1412
1413             if (efl_text_cursor_cluster_coord_set_static_delegate == null)
1414             {
1415                 efl_text_cursor_cluster_coord_set_static_delegate = new efl_text_cursor_cluster_coord_set_delegate(cursor_cluster_coord_set);
1416             }
1417
1418             if (methods.FirstOrDefault(m => m.Name == "SetCursorClusterCoord") != null)
1419             {
1420                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_coord_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_coord_set_static_delegate) });
1421             }
1422
1423             if (efl_text_cursor_text_insert_static_delegate == null)
1424             {
1425                 efl_text_cursor_text_insert_static_delegate = new efl_text_cursor_text_insert_delegate(cursor_text_insert);
1426             }
1427
1428             if (methods.FirstOrDefault(m => m.Name == "CursorTextInsert") != null)
1429             {
1430                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_text_insert"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_text_insert_static_delegate) });
1431             }
1432
1433             if (efl_text_cursor_char_delete_static_delegate == null)
1434             {
1435                 efl_text_cursor_char_delete_static_delegate = new efl_text_cursor_char_delete_delegate(cursor_char_delete);
1436             }
1437
1438             if (methods.FirstOrDefault(m => m.Name == "CursorCharDelete") != null)
1439             {
1440                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_delete"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_delete_static_delegate) });
1441             }
1442
1443             if (efl_text_font_get_static_delegate == null)
1444             {
1445                 efl_text_font_get_static_delegate = new efl_text_font_get_delegate(font_get);
1446             }
1447
1448             if (methods.FirstOrDefault(m => m.Name == "GetFont") != null)
1449             {
1450                 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) });
1451             }
1452
1453             if (efl_text_font_set_static_delegate == null)
1454             {
1455                 efl_text_font_set_static_delegate = new efl_text_font_set_delegate(font_set);
1456             }
1457
1458             if (methods.FirstOrDefault(m => m.Name == "SetFont") != null)
1459             {
1460                 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) });
1461             }
1462
1463             if (efl_text_font_source_get_static_delegate == null)
1464             {
1465                 efl_text_font_source_get_static_delegate = new efl_text_font_source_get_delegate(font_source_get);
1466             }
1467
1468             if (methods.FirstOrDefault(m => m.Name == "GetFontSource") != null)
1469             {
1470                 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) });
1471             }
1472
1473             if (efl_text_font_source_set_static_delegate == null)
1474             {
1475                 efl_text_font_source_set_static_delegate = new efl_text_font_source_set_delegate(font_source_set);
1476             }
1477
1478             if (methods.FirstOrDefault(m => m.Name == "SetFontSource") != null)
1479             {
1480                 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) });
1481             }
1482
1483             if (efl_text_font_fallbacks_get_static_delegate == null)
1484             {
1485                 efl_text_font_fallbacks_get_static_delegate = new efl_text_font_fallbacks_get_delegate(font_fallbacks_get);
1486             }
1487
1488             if (methods.FirstOrDefault(m => m.Name == "GetFontFallbacks") != null)
1489             {
1490                 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) });
1491             }
1492
1493             if (efl_text_font_fallbacks_set_static_delegate == null)
1494             {
1495                 efl_text_font_fallbacks_set_static_delegate = new efl_text_font_fallbacks_set_delegate(font_fallbacks_set);
1496             }
1497
1498             if (methods.FirstOrDefault(m => m.Name == "SetFontFallbacks") != null)
1499             {
1500                 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) });
1501             }
1502
1503             if (efl_text_font_weight_get_static_delegate == null)
1504             {
1505                 efl_text_font_weight_get_static_delegate = new efl_text_font_weight_get_delegate(font_weight_get);
1506             }
1507
1508             if (methods.FirstOrDefault(m => m.Name == "GetFontWeight") != null)
1509             {
1510                 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) });
1511             }
1512
1513             if (efl_text_font_weight_set_static_delegate == null)
1514             {
1515                 efl_text_font_weight_set_static_delegate = new efl_text_font_weight_set_delegate(font_weight_set);
1516             }
1517
1518             if (methods.FirstOrDefault(m => m.Name == "SetFontWeight") != null)
1519             {
1520                 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) });
1521             }
1522
1523             if (efl_text_font_slant_get_static_delegate == null)
1524             {
1525                 efl_text_font_slant_get_static_delegate = new efl_text_font_slant_get_delegate(font_slant_get);
1526             }
1527
1528             if (methods.FirstOrDefault(m => m.Name == "GetFontSlant") != null)
1529             {
1530                 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) });
1531             }
1532
1533             if (efl_text_font_slant_set_static_delegate == null)
1534             {
1535                 efl_text_font_slant_set_static_delegate = new efl_text_font_slant_set_delegate(font_slant_set);
1536             }
1537
1538             if (methods.FirstOrDefault(m => m.Name == "SetFontSlant") != null)
1539             {
1540                 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) });
1541             }
1542
1543             if (efl_text_font_width_get_static_delegate == null)
1544             {
1545                 efl_text_font_width_get_static_delegate = new efl_text_font_width_get_delegate(font_width_get);
1546             }
1547
1548             if (methods.FirstOrDefault(m => m.Name == "GetFontWidth") != null)
1549             {
1550                 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) });
1551             }
1552
1553             if (efl_text_font_width_set_static_delegate == null)
1554             {
1555                 efl_text_font_width_set_static_delegate = new efl_text_font_width_set_delegate(font_width_set);
1556             }
1557
1558             if (methods.FirstOrDefault(m => m.Name == "SetFontWidth") != null)
1559             {
1560                 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) });
1561             }
1562
1563             if (efl_text_font_lang_get_static_delegate == null)
1564             {
1565                 efl_text_font_lang_get_static_delegate = new efl_text_font_lang_get_delegate(font_lang_get);
1566             }
1567
1568             if (methods.FirstOrDefault(m => m.Name == "GetFontLang") != null)
1569             {
1570                 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) });
1571             }
1572
1573             if (efl_text_font_lang_set_static_delegate == null)
1574             {
1575                 efl_text_font_lang_set_static_delegate = new efl_text_font_lang_set_delegate(font_lang_set);
1576             }
1577
1578             if (methods.FirstOrDefault(m => m.Name == "SetFontLang") != null)
1579             {
1580                 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) });
1581             }
1582
1583             if (efl_text_font_bitmap_scalable_get_static_delegate == null)
1584             {
1585                 efl_text_font_bitmap_scalable_get_static_delegate = new efl_text_font_bitmap_scalable_get_delegate(font_bitmap_scalable_get);
1586             }
1587
1588             if (methods.FirstOrDefault(m => m.Name == "GetFontBitmapScalable") != null)
1589             {
1590                 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) });
1591             }
1592
1593             if (efl_text_font_bitmap_scalable_set_static_delegate == null)
1594             {
1595                 efl_text_font_bitmap_scalable_set_static_delegate = new efl_text_font_bitmap_scalable_set_delegate(font_bitmap_scalable_set);
1596             }
1597
1598             if (methods.FirstOrDefault(m => m.Name == "SetFontBitmapScalable") != null)
1599             {
1600                 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) });
1601             }
1602
1603             if (efl_text_ellipsis_get_static_delegate == null)
1604             {
1605                 efl_text_ellipsis_get_static_delegate = new efl_text_ellipsis_get_delegate(ellipsis_get);
1606             }
1607
1608             if (methods.FirstOrDefault(m => m.Name == "GetEllipsis") != null)
1609             {
1610                 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) });
1611             }
1612
1613             if (efl_text_ellipsis_set_static_delegate == null)
1614             {
1615                 efl_text_ellipsis_set_static_delegate = new efl_text_ellipsis_set_delegate(ellipsis_set);
1616             }
1617
1618             if (methods.FirstOrDefault(m => m.Name == "SetEllipsis") != null)
1619             {
1620                 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) });
1621             }
1622
1623             if (efl_text_wrap_get_static_delegate == null)
1624             {
1625                 efl_text_wrap_get_static_delegate = new efl_text_wrap_get_delegate(wrap_get);
1626             }
1627
1628             if (methods.FirstOrDefault(m => m.Name == "GetWrap") != null)
1629             {
1630                 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) });
1631             }
1632
1633             if (efl_text_wrap_set_static_delegate == null)
1634             {
1635                 efl_text_wrap_set_static_delegate = new efl_text_wrap_set_delegate(wrap_set);
1636             }
1637
1638             if (methods.FirstOrDefault(m => m.Name == "SetWrap") != null)
1639             {
1640                 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) });
1641             }
1642
1643             if (efl_text_multiline_get_static_delegate == null)
1644             {
1645                 efl_text_multiline_get_static_delegate = new efl_text_multiline_get_delegate(multiline_get);
1646             }
1647
1648             if (methods.FirstOrDefault(m => m.Name == "GetMultiline") != null)
1649             {
1650                 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) });
1651             }
1652
1653             if (efl_text_multiline_set_static_delegate == null)
1654             {
1655                 efl_text_multiline_set_static_delegate = new efl_text_multiline_set_delegate(multiline_set);
1656             }
1657
1658             if (methods.FirstOrDefault(m => m.Name == "SetMultiline") != null)
1659             {
1660                 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) });
1661             }
1662
1663             if (efl_text_halign_auto_type_get_static_delegate == null)
1664             {
1665                 efl_text_halign_auto_type_get_static_delegate = new efl_text_halign_auto_type_get_delegate(halign_auto_type_get);
1666             }
1667
1668             if (methods.FirstOrDefault(m => m.Name == "GetHalignAutoType") != null)
1669             {
1670                 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) });
1671             }
1672
1673             if (efl_text_halign_auto_type_set_static_delegate == null)
1674             {
1675                 efl_text_halign_auto_type_set_static_delegate = new efl_text_halign_auto_type_set_delegate(halign_auto_type_set);
1676             }
1677
1678             if (methods.FirstOrDefault(m => m.Name == "SetHalignAutoType") != null)
1679             {
1680                 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) });
1681             }
1682
1683             if (efl_text_halign_get_static_delegate == null)
1684             {
1685                 efl_text_halign_get_static_delegate = new efl_text_halign_get_delegate(halign_get);
1686             }
1687
1688             if (methods.FirstOrDefault(m => m.Name == "GetHalign") != null)
1689             {
1690                 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) });
1691             }
1692
1693             if (efl_text_halign_set_static_delegate == null)
1694             {
1695                 efl_text_halign_set_static_delegate = new efl_text_halign_set_delegate(halign_set);
1696             }
1697
1698             if (methods.FirstOrDefault(m => m.Name == "SetHalign") != null)
1699             {
1700                 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) });
1701             }
1702
1703             if (efl_text_valign_get_static_delegate == null)
1704             {
1705                 efl_text_valign_get_static_delegate = new efl_text_valign_get_delegate(valign_get);
1706             }
1707
1708             if (methods.FirstOrDefault(m => m.Name == "GetValign") != null)
1709             {
1710                 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) });
1711             }
1712
1713             if (efl_text_valign_set_static_delegate == null)
1714             {
1715                 efl_text_valign_set_static_delegate = new efl_text_valign_set_delegate(valign_set);
1716             }
1717
1718             if (methods.FirstOrDefault(m => m.Name == "SetValign") != null)
1719             {
1720                 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) });
1721             }
1722
1723             if (efl_text_linegap_get_static_delegate == null)
1724             {
1725                 efl_text_linegap_get_static_delegate = new efl_text_linegap_get_delegate(linegap_get);
1726             }
1727
1728             if (methods.FirstOrDefault(m => m.Name == "GetLinegap") != null)
1729             {
1730                 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) });
1731             }
1732
1733             if (efl_text_linegap_set_static_delegate == null)
1734             {
1735                 efl_text_linegap_set_static_delegate = new efl_text_linegap_set_delegate(linegap_set);
1736             }
1737
1738             if (methods.FirstOrDefault(m => m.Name == "SetLinegap") != null)
1739             {
1740                 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) });
1741             }
1742
1743             if (efl_text_linerelgap_get_static_delegate == null)
1744             {
1745                 efl_text_linerelgap_get_static_delegate = new efl_text_linerelgap_get_delegate(linerelgap_get);
1746             }
1747
1748             if (methods.FirstOrDefault(m => m.Name == "GetLinerelgap") != null)
1749             {
1750                 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) });
1751             }
1752
1753             if (efl_text_linerelgap_set_static_delegate == null)
1754             {
1755                 efl_text_linerelgap_set_static_delegate = new efl_text_linerelgap_set_delegate(linerelgap_set);
1756             }
1757
1758             if (methods.FirstOrDefault(m => m.Name == "SetLinerelgap") != null)
1759             {
1760                 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) });
1761             }
1762
1763             if (efl_text_tabstops_get_static_delegate == null)
1764             {
1765                 efl_text_tabstops_get_static_delegate = new efl_text_tabstops_get_delegate(tabstops_get);
1766             }
1767
1768             if (methods.FirstOrDefault(m => m.Name == "GetTabstops") != null)
1769             {
1770                 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) });
1771             }
1772
1773             if (efl_text_tabstops_set_static_delegate == null)
1774             {
1775                 efl_text_tabstops_set_static_delegate = new efl_text_tabstops_set_delegate(tabstops_set);
1776             }
1777
1778             if (methods.FirstOrDefault(m => m.Name == "SetTabstops") != null)
1779             {
1780                 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) });
1781             }
1782
1783             if (efl_text_password_get_static_delegate == null)
1784             {
1785                 efl_text_password_get_static_delegate = new efl_text_password_get_delegate(password_get);
1786             }
1787
1788             if (methods.FirstOrDefault(m => m.Name == "GetPassword") != null)
1789             {
1790                 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) });
1791             }
1792
1793             if (efl_text_password_set_static_delegate == null)
1794             {
1795                 efl_text_password_set_static_delegate = new efl_text_password_set_delegate(password_set);
1796             }
1797
1798             if (methods.FirstOrDefault(m => m.Name == "SetPassword") != null)
1799             {
1800                 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) });
1801             }
1802
1803             if (efl_text_replacement_char_get_static_delegate == null)
1804             {
1805                 efl_text_replacement_char_get_static_delegate = new efl_text_replacement_char_get_delegate(replacement_char_get);
1806             }
1807
1808             if (methods.FirstOrDefault(m => m.Name == "GetReplacementChar") != null)
1809             {
1810                 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) });
1811             }
1812
1813             if (efl_text_replacement_char_set_static_delegate == null)
1814             {
1815                 efl_text_replacement_char_set_static_delegate = new efl_text_replacement_char_set_delegate(replacement_char_set);
1816             }
1817
1818             if (methods.FirstOrDefault(m => m.Name == "SetReplacementChar") != null)
1819             {
1820                 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) });
1821             }
1822
1823             if (efl_text_markup_get_static_delegate == null)
1824             {
1825                 efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
1826             }
1827
1828             if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
1829             {
1830                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
1831             }
1832
1833             if (efl_text_markup_set_static_delegate == null)
1834             {
1835                 efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
1836             }
1837
1838             if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
1839             {
1840                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
1841             }
1842
1843             if (efl_text_markup_interactive_markup_range_get_static_delegate == null)
1844             {
1845                 efl_text_markup_interactive_markup_range_get_static_delegate = new efl_text_markup_interactive_markup_range_get_delegate(markup_range_get);
1846             }
1847
1848             if (methods.FirstOrDefault(m => m.Name == "GetMarkupRange") != null)
1849             {
1850                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_markup_range_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_markup_range_get_static_delegate) });
1851             }
1852
1853             if (efl_text_markup_interactive_markup_range_set_static_delegate == null)
1854             {
1855                 efl_text_markup_interactive_markup_range_set_static_delegate = new efl_text_markup_interactive_markup_range_set_delegate(markup_range_set);
1856             }
1857
1858             if (methods.FirstOrDefault(m => m.Name == "SetMarkupRange") != null)
1859             {
1860                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_markup_range_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_markup_range_set_static_delegate) });
1861             }
1862
1863             if (efl_text_markup_interactive_cursor_markup_insert_static_delegate == null)
1864             {
1865                 efl_text_markup_interactive_cursor_markup_insert_static_delegate = new efl_text_markup_interactive_cursor_markup_insert_delegate(cursor_markup_insert);
1866             }
1867
1868             if (methods.FirstOrDefault(m => m.Name == "CursorMarkupInsert") != null)
1869             {
1870                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_cursor_markup_insert"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_cursor_markup_insert_static_delegate) });
1871             }
1872
1873             if (efl_text_normal_color_get_static_delegate == null)
1874             {
1875                 efl_text_normal_color_get_static_delegate = new efl_text_normal_color_get_delegate(normal_color_get);
1876             }
1877
1878             if (methods.FirstOrDefault(m => m.Name == "GetNormalColor") != null)
1879             {
1880                 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) });
1881             }
1882
1883             if (efl_text_normal_color_set_static_delegate == null)
1884             {
1885                 efl_text_normal_color_set_static_delegate = new efl_text_normal_color_set_delegate(normal_color_set);
1886             }
1887
1888             if (methods.FirstOrDefault(m => m.Name == "SetNormalColor") != null)
1889             {
1890                 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) });
1891             }
1892
1893             if (efl_text_backing_type_get_static_delegate == null)
1894             {
1895                 efl_text_backing_type_get_static_delegate = new efl_text_backing_type_get_delegate(backing_type_get);
1896             }
1897
1898             if (methods.FirstOrDefault(m => m.Name == "GetBackingType") != null)
1899             {
1900                 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) });
1901             }
1902
1903             if (efl_text_backing_type_set_static_delegate == null)
1904             {
1905                 efl_text_backing_type_set_static_delegate = new efl_text_backing_type_set_delegate(backing_type_set);
1906             }
1907
1908             if (methods.FirstOrDefault(m => m.Name == "SetBackingType") != null)
1909             {
1910                 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) });
1911             }
1912
1913             if (efl_text_backing_color_get_static_delegate == null)
1914             {
1915                 efl_text_backing_color_get_static_delegate = new efl_text_backing_color_get_delegate(backing_color_get);
1916             }
1917
1918             if (methods.FirstOrDefault(m => m.Name == "GetBackingColor") != null)
1919             {
1920                 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) });
1921             }
1922
1923             if (efl_text_backing_color_set_static_delegate == null)
1924             {
1925                 efl_text_backing_color_set_static_delegate = new efl_text_backing_color_set_delegate(backing_color_set);
1926             }
1927
1928             if (methods.FirstOrDefault(m => m.Name == "SetBackingColor") != null)
1929             {
1930                 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) });
1931             }
1932
1933             if (efl_text_underline_type_get_static_delegate == null)
1934             {
1935                 efl_text_underline_type_get_static_delegate = new efl_text_underline_type_get_delegate(underline_type_get);
1936             }
1937
1938             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineType") != null)
1939             {
1940                 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) });
1941             }
1942
1943             if (efl_text_underline_type_set_static_delegate == null)
1944             {
1945                 efl_text_underline_type_set_static_delegate = new efl_text_underline_type_set_delegate(underline_type_set);
1946             }
1947
1948             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineType") != null)
1949             {
1950                 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) });
1951             }
1952
1953             if (efl_text_underline_color_get_static_delegate == null)
1954             {
1955                 efl_text_underline_color_get_static_delegate = new efl_text_underline_color_get_delegate(underline_color_get);
1956             }
1957
1958             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineColor") != null)
1959             {
1960                 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) });
1961             }
1962
1963             if (efl_text_underline_color_set_static_delegate == null)
1964             {
1965                 efl_text_underline_color_set_static_delegate = new efl_text_underline_color_set_delegate(underline_color_set);
1966             }
1967
1968             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineColor") != null)
1969             {
1970                 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) });
1971             }
1972
1973             if (efl_text_underline_height_get_static_delegate == null)
1974             {
1975                 efl_text_underline_height_get_static_delegate = new efl_text_underline_height_get_delegate(underline_height_get);
1976             }
1977
1978             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineHeight") != null)
1979             {
1980                 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) });
1981             }
1982
1983             if (efl_text_underline_height_set_static_delegate == null)
1984             {
1985                 efl_text_underline_height_set_static_delegate = new efl_text_underline_height_set_delegate(underline_height_set);
1986             }
1987
1988             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineHeight") != null)
1989             {
1990                 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) });
1991             }
1992
1993             if (efl_text_underline_dashed_color_get_static_delegate == null)
1994             {
1995                 efl_text_underline_dashed_color_get_static_delegate = new efl_text_underline_dashed_color_get_delegate(underline_dashed_color_get);
1996             }
1997
1998             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedColor") != null)
1999             {
2000                 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) });
2001             }
2002
2003             if (efl_text_underline_dashed_color_set_static_delegate == null)
2004             {
2005                 efl_text_underline_dashed_color_set_static_delegate = new efl_text_underline_dashed_color_set_delegate(underline_dashed_color_set);
2006             }
2007
2008             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedColor") != null)
2009             {
2010                 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) });
2011             }
2012
2013             if (efl_text_underline_dashed_width_get_static_delegate == null)
2014             {
2015                 efl_text_underline_dashed_width_get_static_delegate = new efl_text_underline_dashed_width_get_delegate(underline_dashed_width_get);
2016             }
2017
2018             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedWidth") != null)
2019             {
2020                 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) });
2021             }
2022
2023             if (efl_text_underline_dashed_width_set_static_delegate == null)
2024             {
2025                 efl_text_underline_dashed_width_set_static_delegate = new efl_text_underline_dashed_width_set_delegate(underline_dashed_width_set);
2026             }
2027
2028             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedWidth") != null)
2029             {
2030                 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) });
2031             }
2032
2033             if (efl_text_underline_dashed_gap_get_static_delegate == null)
2034             {
2035                 efl_text_underline_dashed_gap_get_static_delegate = new efl_text_underline_dashed_gap_get_delegate(underline_dashed_gap_get);
2036             }
2037
2038             if (methods.FirstOrDefault(m => m.Name == "GetUnderlineDashedGap") != null)
2039             {
2040                 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) });
2041             }
2042
2043             if (efl_text_underline_dashed_gap_set_static_delegate == null)
2044             {
2045                 efl_text_underline_dashed_gap_set_static_delegate = new efl_text_underline_dashed_gap_set_delegate(underline_dashed_gap_set);
2046             }
2047
2048             if (methods.FirstOrDefault(m => m.Name == "SetUnderlineDashedGap") != null)
2049             {
2050                 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) });
2051             }
2052
2053             if (efl_text_underline2_color_get_static_delegate == null)
2054             {
2055                 efl_text_underline2_color_get_static_delegate = new efl_text_underline2_color_get_delegate(underline2_color_get);
2056             }
2057
2058             if (methods.FirstOrDefault(m => m.Name == "GetUnderline2Color") != null)
2059             {
2060                 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) });
2061             }
2062
2063             if (efl_text_underline2_color_set_static_delegate == null)
2064             {
2065                 efl_text_underline2_color_set_static_delegate = new efl_text_underline2_color_set_delegate(underline2_color_set);
2066             }
2067
2068             if (methods.FirstOrDefault(m => m.Name == "SetUnderline2Color") != null)
2069             {
2070                 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) });
2071             }
2072
2073             if (efl_text_strikethrough_type_get_static_delegate == null)
2074             {
2075                 efl_text_strikethrough_type_get_static_delegate = new efl_text_strikethrough_type_get_delegate(strikethrough_type_get);
2076             }
2077
2078             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughType") != null)
2079             {
2080                 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) });
2081             }
2082
2083             if (efl_text_strikethrough_type_set_static_delegate == null)
2084             {
2085                 efl_text_strikethrough_type_set_static_delegate = new efl_text_strikethrough_type_set_delegate(strikethrough_type_set);
2086             }
2087
2088             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughType") != null)
2089             {
2090                 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) });
2091             }
2092
2093             if (efl_text_strikethrough_color_get_static_delegate == null)
2094             {
2095                 efl_text_strikethrough_color_get_static_delegate = new efl_text_strikethrough_color_get_delegate(strikethrough_color_get);
2096             }
2097
2098             if (methods.FirstOrDefault(m => m.Name == "GetStrikethroughColor") != null)
2099             {
2100                 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) });
2101             }
2102
2103             if (efl_text_strikethrough_color_set_static_delegate == null)
2104             {
2105                 efl_text_strikethrough_color_set_static_delegate = new efl_text_strikethrough_color_set_delegate(strikethrough_color_set);
2106             }
2107
2108             if (methods.FirstOrDefault(m => m.Name == "SetStrikethroughColor") != null)
2109             {
2110                 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) });
2111             }
2112
2113             if (efl_text_effect_type_get_static_delegate == null)
2114             {
2115                 efl_text_effect_type_get_static_delegate = new efl_text_effect_type_get_delegate(effect_type_get);
2116             }
2117
2118             if (methods.FirstOrDefault(m => m.Name == "GetEffectType") != null)
2119             {
2120                 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) });
2121             }
2122
2123             if (efl_text_effect_type_set_static_delegate == null)
2124             {
2125                 efl_text_effect_type_set_static_delegate = new efl_text_effect_type_set_delegate(effect_type_set);
2126             }
2127
2128             if (methods.FirstOrDefault(m => m.Name == "SetEffectType") != null)
2129             {
2130                 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) });
2131             }
2132
2133             if (efl_text_outline_color_get_static_delegate == null)
2134             {
2135                 efl_text_outline_color_get_static_delegate = new efl_text_outline_color_get_delegate(outline_color_get);
2136             }
2137
2138             if (methods.FirstOrDefault(m => m.Name == "GetOutlineColor") != null)
2139             {
2140                 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) });
2141             }
2142
2143             if (efl_text_outline_color_set_static_delegate == null)
2144             {
2145                 efl_text_outline_color_set_static_delegate = new efl_text_outline_color_set_delegate(outline_color_set);
2146             }
2147
2148             if (methods.FirstOrDefault(m => m.Name == "SetOutlineColor") != null)
2149             {
2150                 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) });
2151             }
2152
2153             if (efl_text_shadow_direction_get_static_delegate == null)
2154             {
2155                 efl_text_shadow_direction_get_static_delegate = new efl_text_shadow_direction_get_delegate(shadow_direction_get);
2156             }
2157
2158             if (methods.FirstOrDefault(m => m.Name == "GetShadowDirection") != null)
2159             {
2160                 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) });
2161             }
2162
2163             if (efl_text_shadow_direction_set_static_delegate == null)
2164             {
2165                 efl_text_shadow_direction_set_static_delegate = new efl_text_shadow_direction_set_delegate(shadow_direction_set);
2166             }
2167
2168             if (methods.FirstOrDefault(m => m.Name == "SetShadowDirection") != null)
2169             {
2170                 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) });
2171             }
2172
2173             if (efl_text_shadow_color_get_static_delegate == null)
2174             {
2175                 efl_text_shadow_color_get_static_delegate = new efl_text_shadow_color_get_delegate(shadow_color_get);
2176             }
2177
2178             if (methods.FirstOrDefault(m => m.Name == "GetShadowColor") != null)
2179             {
2180                 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) });
2181             }
2182
2183             if (efl_text_shadow_color_set_static_delegate == null)
2184             {
2185                 efl_text_shadow_color_set_static_delegate = new efl_text_shadow_color_set_delegate(shadow_color_set);
2186             }
2187
2188             if (methods.FirstOrDefault(m => m.Name == "SetShadowColor") != null)
2189             {
2190                 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) });
2191             }
2192
2193             if (efl_text_glow_color_get_static_delegate == null)
2194             {
2195                 efl_text_glow_color_get_static_delegate = new efl_text_glow_color_get_delegate(glow_color_get);
2196             }
2197
2198             if (methods.FirstOrDefault(m => m.Name == "GetGlowColor") != null)
2199             {
2200                 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) });
2201             }
2202
2203             if (efl_text_glow_color_set_static_delegate == null)
2204             {
2205                 efl_text_glow_color_set_static_delegate = new efl_text_glow_color_set_delegate(glow_color_set);
2206             }
2207
2208             if (methods.FirstOrDefault(m => m.Name == "SetGlowColor") != null)
2209             {
2210                 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) });
2211             }
2212
2213             if (efl_text_glow2_color_get_static_delegate == null)
2214             {
2215                 efl_text_glow2_color_get_static_delegate = new efl_text_glow2_color_get_delegate(glow2_color_get);
2216             }
2217
2218             if (methods.FirstOrDefault(m => m.Name == "GetGlow2Color") != null)
2219             {
2220                 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) });
2221             }
2222
2223             if (efl_text_glow2_color_set_static_delegate == null)
2224             {
2225                 efl_text_glow2_color_set_static_delegate = new efl_text_glow2_color_set_delegate(glow2_color_set);
2226             }
2227
2228             if (methods.FirstOrDefault(m => m.Name == "SetGlow2Color") != null)
2229             {
2230                 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) });
2231             }
2232
2233             if (efl_text_gfx_filter_get_static_delegate == null)
2234             {
2235                 efl_text_gfx_filter_get_static_delegate = new efl_text_gfx_filter_get_delegate(gfx_filter_get);
2236             }
2237
2238             if (methods.FirstOrDefault(m => m.Name == "GetGfxFilter") != null)
2239             {
2240                 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) });
2241             }
2242
2243             if (efl_text_gfx_filter_set_static_delegate == null)
2244             {
2245                 efl_text_gfx_filter_set_static_delegate = new efl_text_gfx_filter_set_delegate(gfx_filter_set);
2246             }
2247
2248             if (methods.FirstOrDefault(m => m.Name == "SetGfxFilter") != null)
2249             {
2250                 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) });
2251             }
2252
2253             descs.AddRange(base.GetEoOps(type));
2254             return descs;
2255         }
2256         /// <summary>Returns the Eo class for the native methods of this class.</summary>
2257         /// <returns>The native class pointer.</returns>
2258         public override IntPtr GetEflClass()
2259         {
2260             return Efl.Canvas.LayoutPartText.efl_canvas_layout_part_text_class_get();
2261         }
2262
2263         #pragma warning disable CA1707, CS1591, SA1300, SA1600
2264
2265
2266         private delegate Efl.Canvas.LayoutPartTextExpand efl_canvas_layout_part_text_expand_get_delegate(System.IntPtr obj, System.IntPtr pd);
2267
2268
2269         public delegate Efl.Canvas.LayoutPartTextExpand efl_canvas_layout_part_text_expand_get_api_delegate(System.IntPtr obj);
2270
2271         public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_expand_get_api_delegate> efl_canvas_layout_part_text_expand_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_expand_get_api_delegate>(Module, "efl_canvas_layout_part_text_expand_get");
2272
2273         private static Efl.Canvas.LayoutPartTextExpand text_expand_get(System.IntPtr obj, System.IntPtr pd)
2274         {
2275             Eina.Log.Debug("function efl_canvas_layout_part_text_expand_get was called");
2276             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2277             if (ws != null)
2278             {
2279             Efl.Canvas.LayoutPartTextExpand _ret_var = default(Efl.Canvas.LayoutPartTextExpand);
2280                 try
2281                 {
2282                     _ret_var = ((LayoutPartText)ws.Target).GetTextExpand();
2283                 }
2284                 catch (Exception e)
2285                 {
2286                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2287                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2288                 }
2289
2290         return _ret_var;
2291
2292             }
2293             else
2294             {
2295                 return efl_canvas_layout_part_text_expand_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2296             }
2297         }
2298
2299         private static efl_canvas_layout_part_text_expand_get_delegate efl_canvas_layout_part_text_expand_get_static_delegate;
2300
2301
2302         private delegate void efl_canvas_layout_part_text_expand_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.LayoutPartTextExpand type);
2303
2304
2305         public delegate void efl_canvas_layout_part_text_expand_set_api_delegate(System.IntPtr obj,  Efl.Canvas.LayoutPartTextExpand type);
2306
2307         public static Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_expand_set_api_delegate> efl_canvas_layout_part_text_expand_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_layout_part_text_expand_set_api_delegate>(Module, "efl_canvas_layout_part_text_expand_set");
2308
2309         private static void text_expand_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.LayoutPartTextExpand type)
2310         {
2311             Eina.Log.Debug("function efl_canvas_layout_part_text_expand_set was called");
2312             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2313             if (ws != null)
2314             {
2315
2316                 try
2317                 {
2318                     ((LayoutPartText)ws.Target).SetTextExpand(type);
2319                 }
2320                 catch (Exception e)
2321                 {
2322                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2323                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2324                 }
2325
2326
2327             }
2328             else
2329             {
2330                 efl_canvas_layout_part_text_expand_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
2331             }
2332         }
2333
2334         private static efl_canvas_layout_part_text_expand_set_delegate efl_canvas_layout_part_text_expand_set_static_delegate;
2335
2336         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2337         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
2338
2339         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2340         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
2341
2342         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");
2343
2344         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
2345         {
2346             Eina.Log.Debug("function efl_text_get was called");
2347             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2348             if (ws != null)
2349             {
2350             System.String _ret_var = default(System.String);
2351                 try
2352                 {
2353                     _ret_var = ((LayoutPartText)ws.Target).GetText();
2354                 }
2355                 catch (Exception e)
2356                 {
2357                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2358                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2359                 }
2360
2361         return _ret_var;
2362
2363             }
2364             else
2365             {
2366                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2367             }
2368         }
2369
2370         private static efl_text_get_delegate efl_text_get_static_delegate;
2371
2372
2373         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2374
2375
2376         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2377
2378         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");
2379
2380         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
2381         {
2382             Eina.Log.Debug("function efl_text_set was called");
2383             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2384             if (ws != null)
2385             {
2386
2387                 try
2388                 {
2389                     ((LayoutPartText)ws.Target).SetText(text);
2390                 }
2391                 catch (Exception e)
2392                 {
2393                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2394                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2395                 }
2396
2397
2398             }
2399             else
2400             {
2401                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
2402             }
2403         }
2404
2405         private static efl_text_set_delegate efl_text_set_static_delegate;
2406
2407
2408         private delegate Efl.TextCursorCursor efl_text_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorGetType get_type);
2409
2410
2411         public delegate Efl.TextCursorCursor efl_text_cursor_get_api_delegate(System.IntPtr obj,  Efl.TextCursorGetType get_type);
2412
2413         public static Efl.Eo.FunctionWrapper<efl_text_cursor_get_api_delegate> efl_text_cursor_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_get_api_delegate>(Module, "efl_text_cursor_get");
2414
2415         private static Efl.TextCursorCursor text_cursor_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorGetType get_type)
2416         {
2417             Eina.Log.Debug("function efl_text_cursor_get was called");
2418             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2419             if (ws != null)
2420             {
2421                                     Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
2422                 try
2423                 {
2424                     _ret_var = ((LayoutPartText)ws.Target).GetTextCursor(get_type);
2425                 }
2426                 catch (Exception e)
2427                 {
2428                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2429                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2430                 }
2431
2432                         return _ret_var;
2433
2434             }
2435             else
2436             {
2437                 return efl_text_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), get_type);
2438             }
2439         }
2440
2441         private static efl_text_cursor_get_delegate efl_text_cursor_get_static_delegate;
2442
2443
2444         private delegate int efl_text_cursor_position_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2445
2446
2447         public delegate int efl_text_cursor_position_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2448
2449         public static Efl.Eo.FunctionWrapper<efl_text_cursor_position_get_api_delegate> efl_text_cursor_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_position_get_api_delegate>(Module, "efl_text_cursor_position_get");
2450
2451         private static int cursor_position_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2452         {
2453             Eina.Log.Debug("function efl_text_cursor_position_get was called");
2454             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2455             if (ws != null)
2456             {
2457                                     int _ret_var = default(int);
2458                 try
2459                 {
2460                     _ret_var = ((LayoutPartText)ws.Target).GetCursorPosition(cur);
2461                 }
2462                 catch (Exception e)
2463                 {
2464                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2465                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2466                 }
2467
2468                         return _ret_var;
2469
2470             }
2471             else
2472             {
2473                 return efl_text_cursor_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2474             }
2475         }
2476
2477         private static efl_text_cursor_position_get_delegate efl_text_cursor_position_get_static_delegate;
2478
2479
2480         private delegate void efl_text_cursor_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int position);
2481
2482
2483         public delegate void efl_text_cursor_position_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int position);
2484
2485         public static Efl.Eo.FunctionWrapper<efl_text_cursor_position_set_api_delegate> efl_text_cursor_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_position_set_api_delegate>(Module, "efl_text_cursor_position_set");
2486
2487         private static void cursor_position_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int position)
2488         {
2489             Eina.Log.Debug("function efl_text_cursor_position_set was called");
2490             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2491             if (ws != null)
2492             {
2493
2494                 try
2495                 {
2496                     ((LayoutPartText)ws.Target).SetCursorPosition(cur, position);
2497                 }
2498                 catch (Exception e)
2499                 {
2500                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2501                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2502                 }
2503
2504
2505             }
2506             else
2507             {
2508                 efl_text_cursor_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, position);
2509             }
2510         }
2511
2512         private static efl_text_cursor_position_set_delegate efl_text_cursor_position_set_static_delegate;
2513
2514
2515         private delegate Eina.Unicode efl_text_cursor_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2516
2517
2518         public delegate Eina.Unicode efl_text_cursor_content_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2519
2520         public static Efl.Eo.FunctionWrapper<efl_text_cursor_content_get_api_delegate> efl_text_cursor_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_content_get_api_delegate>(Module, "efl_text_cursor_content_get");
2521
2522         private static Eina.Unicode cursor_content_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2523         {
2524             Eina.Log.Debug("function efl_text_cursor_content_get was called");
2525             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2526             if (ws != null)
2527             {
2528                                     Eina.Unicode _ret_var = default(Eina.Unicode);
2529                 try
2530                 {
2531                     _ret_var = ((LayoutPartText)ws.Target).GetCursorContent(cur);
2532                 }
2533                 catch (Exception e)
2534                 {
2535                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2536                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2537                 }
2538
2539                         return _ret_var;
2540
2541             }
2542             else
2543             {
2544                 return efl_text_cursor_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2545             }
2546         }
2547
2548         private static efl_text_cursor_content_get_delegate efl_text_cursor_content_get_static_delegate;
2549
2550         [return: MarshalAs(UnmanagedType.U1)]
2551         private delegate bool efl_text_cursor_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  Efl.TextCursorType ctype,  out int cx,  out int cy,  out int cw,  out int ch,  out int cx2,  out int cy2,  out int cw2,  out int ch2);
2552
2553         [return: MarshalAs(UnmanagedType.U1)]
2554         public delegate bool efl_text_cursor_geometry_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  Efl.TextCursorType ctype,  out int cx,  out int cy,  out int cw,  out int ch,  out int cx2,  out int cy2,  out int cw2,  out int ch2);
2555
2556         public static Efl.Eo.FunctionWrapper<efl_text_cursor_geometry_get_api_delegate> efl_text_cursor_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_geometry_get_api_delegate>(Module, "efl_text_cursor_geometry_get");
2557
2558         private static bool cursor_geometry_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2)
2559         {
2560             Eina.Log.Debug("function efl_text_cursor_geometry_get was called");
2561             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2562             if (ws != null)
2563             {
2564                                                                                                         cx = default(int);        cy = default(int);        cw = default(int);        ch = default(int);        cx2 = default(int);        cy2 = default(int);        cw2 = default(int);        ch2 = default(int);                                                                                            bool _ret_var = default(bool);
2565                 try
2566                 {
2567                     _ret_var = ((LayoutPartText)ws.Target).GetCursorGeometry(cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
2568                 }
2569                 catch (Exception e)
2570                 {
2571                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2572                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2573                 }
2574
2575                                                                                                                                                                         return _ret_var;
2576
2577             }
2578             else
2579             {
2580                 return efl_text_cursor_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
2581             }
2582         }
2583
2584         private static efl_text_cursor_geometry_get_delegate efl_text_cursor_geometry_get_static_delegate;
2585
2586
2587         private delegate Efl.TextCursorCursor efl_text_cursor_new_delegate(System.IntPtr obj, System.IntPtr pd);
2588
2589
2590         public delegate Efl.TextCursorCursor efl_text_cursor_new_api_delegate(System.IntPtr obj);
2591
2592         public static Efl.Eo.FunctionWrapper<efl_text_cursor_new_api_delegate> efl_text_cursor_new_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_new_api_delegate>(Module, "efl_text_cursor_new");
2593
2594         private static Efl.TextCursorCursor cursor_new(System.IntPtr obj, System.IntPtr pd)
2595         {
2596             Eina.Log.Debug("function efl_text_cursor_new was called");
2597             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2598             if (ws != null)
2599             {
2600             Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
2601                 try
2602                 {
2603                     _ret_var = ((LayoutPartText)ws.Target).NewCursor();
2604                 }
2605                 catch (Exception e)
2606                 {
2607                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2608                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2609                 }
2610
2611         return _ret_var;
2612
2613             }
2614             else
2615             {
2616                 return efl_text_cursor_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2617             }
2618         }
2619
2620         private static efl_text_cursor_new_delegate efl_text_cursor_new_static_delegate;
2621
2622
2623         private delegate void efl_text_cursor_free_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2624
2625
2626         public delegate void efl_text_cursor_free_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2627
2628         public static Efl.Eo.FunctionWrapper<efl_text_cursor_free_api_delegate> efl_text_cursor_free_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_free_api_delegate>(Module, "efl_text_cursor_free");
2629
2630         private static void cursor_free(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2631         {
2632             Eina.Log.Debug("function efl_text_cursor_free was called");
2633             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2634             if (ws != null)
2635             {
2636
2637                 try
2638                 {
2639                     ((LayoutPartText)ws.Target).CursorFree(cur);
2640                 }
2641                 catch (Exception e)
2642                 {
2643                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2644                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2645                 }
2646
2647
2648             }
2649             else
2650             {
2651                 efl_text_cursor_free_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2652             }
2653         }
2654
2655         private static efl_text_cursor_free_delegate efl_text_cursor_free_static_delegate;
2656
2657         [return: MarshalAs(UnmanagedType.U1)]
2658         private delegate bool efl_text_cursor_equal_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2659
2660         [return: MarshalAs(UnmanagedType.U1)]
2661         public delegate bool efl_text_cursor_equal_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2662
2663         public static Efl.Eo.FunctionWrapper<efl_text_cursor_equal_api_delegate> efl_text_cursor_equal_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_equal_api_delegate>(Module, "efl_text_cursor_equal");
2664
2665         private static bool cursor_equal(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
2666         {
2667             Eina.Log.Debug("function efl_text_cursor_equal was called");
2668             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2669             if (ws != null)
2670             {
2671                                                             bool _ret_var = default(bool);
2672                 try
2673                 {
2674                     _ret_var = ((LayoutPartText)ws.Target).CursorEqual(cur1, cur2);
2675                 }
2676                 catch (Exception e)
2677                 {
2678                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2679                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2680                 }
2681
2682                                         return _ret_var;
2683
2684             }
2685             else
2686             {
2687                 return efl_text_cursor_equal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
2688             }
2689         }
2690
2691         private static efl_text_cursor_equal_delegate efl_text_cursor_equal_static_delegate;
2692
2693
2694         private delegate int efl_text_cursor_compare_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2695
2696
2697         public delegate int efl_text_cursor_compare_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2698
2699         public static Efl.Eo.FunctionWrapper<efl_text_cursor_compare_api_delegate> efl_text_cursor_compare_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_compare_api_delegate>(Module, "efl_text_cursor_compare");
2700
2701         private static int cursor_compare(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
2702         {
2703             Eina.Log.Debug("function efl_text_cursor_compare was called");
2704             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2705             if (ws != null)
2706             {
2707                                                             int _ret_var = default(int);
2708                 try
2709                 {
2710                     _ret_var = ((LayoutPartText)ws.Target).CursorCompare(cur1, cur2);
2711                 }
2712                 catch (Exception e)
2713                 {
2714                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2715                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2716                 }
2717
2718                                         return _ret_var;
2719
2720             }
2721             else
2722             {
2723                 return efl_text_cursor_compare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
2724             }
2725         }
2726
2727         private static efl_text_cursor_compare_delegate efl_text_cursor_compare_static_delegate;
2728
2729
2730         private delegate void efl_text_cursor_copy_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
2731
2732
2733         public delegate void efl_text_cursor_copy_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
2734
2735         public static Efl.Eo.FunctionWrapper<efl_text_cursor_copy_api_delegate> efl_text_cursor_copy_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_copy_api_delegate>(Module, "efl_text_cursor_copy");
2736
2737         private static void cursor_copy(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor dst, Efl.TextCursorCursor src)
2738         {
2739             Eina.Log.Debug("function efl_text_cursor_copy was called");
2740             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2741             if (ws != null)
2742             {
2743
2744                 try
2745                 {
2746                     ((LayoutPartText)ws.Target).CursorCopy(dst, src);
2747                 }
2748                 catch (Exception e)
2749                 {
2750                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2751                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2752                 }
2753
2754
2755             }
2756             else
2757             {
2758                 efl_text_cursor_copy_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dst, src);
2759             }
2760         }
2761
2762         private static efl_text_cursor_copy_delegate efl_text_cursor_copy_static_delegate;
2763
2764
2765         private delegate void efl_text_cursor_char_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2766
2767
2768         public delegate void efl_text_cursor_char_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2769
2770         public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_next_api_delegate> efl_text_cursor_char_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_next_api_delegate>(Module, "efl_text_cursor_char_next");
2771
2772         private static void cursor_char_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2773         {
2774             Eina.Log.Debug("function efl_text_cursor_char_next was called");
2775             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2776             if (ws != null)
2777             {
2778
2779                 try
2780                 {
2781                     ((LayoutPartText)ws.Target).CursorCharNext(cur);
2782                 }
2783                 catch (Exception e)
2784                 {
2785                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2786                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2787                 }
2788
2789
2790             }
2791             else
2792             {
2793                 efl_text_cursor_char_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2794             }
2795         }
2796
2797         private static efl_text_cursor_char_next_delegate efl_text_cursor_char_next_static_delegate;
2798
2799
2800         private delegate void efl_text_cursor_char_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2801
2802
2803         public delegate void efl_text_cursor_char_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2804
2805         public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_prev_api_delegate> efl_text_cursor_char_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_prev_api_delegate>(Module, "efl_text_cursor_char_prev");
2806
2807         private static void cursor_char_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2808         {
2809             Eina.Log.Debug("function efl_text_cursor_char_prev was called");
2810             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2811             if (ws != null)
2812             {
2813
2814                 try
2815                 {
2816                     ((LayoutPartText)ws.Target).CursorCharPrev(cur);
2817                 }
2818                 catch (Exception e)
2819                 {
2820                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2821                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2822                 }
2823
2824
2825             }
2826             else
2827             {
2828                 efl_text_cursor_char_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2829             }
2830         }
2831
2832         private static efl_text_cursor_char_prev_delegate efl_text_cursor_char_prev_static_delegate;
2833
2834
2835         private delegate void efl_text_cursor_cluster_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2836
2837
2838         public delegate void efl_text_cursor_cluster_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2839
2840         public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_next_api_delegate> efl_text_cursor_cluster_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_next_api_delegate>(Module, "efl_text_cursor_cluster_next");
2841
2842         private static void cursor_cluster_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2843         {
2844             Eina.Log.Debug("function efl_text_cursor_cluster_next was called");
2845             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2846             if (ws != null)
2847             {
2848
2849                 try
2850                 {
2851                     ((LayoutPartText)ws.Target).CursorClusterNext(cur);
2852                 }
2853                 catch (Exception e)
2854                 {
2855                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2856                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2857                 }
2858
2859
2860             }
2861             else
2862             {
2863                 efl_text_cursor_cluster_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2864             }
2865         }
2866
2867         private static efl_text_cursor_cluster_next_delegate efl_text_cursor_cluster_next_static_delegate;
2868
2869
2870         private delegate void efl_text_cursor_cluster_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2871
2872
2873         public delegate void efl_text_cursor_cluster_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2874
2875         public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_prev_api_delegate> efl_text_cursor_cluster_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_prev_api_delegate>(Module, "efl_text_cursor_cluster_prev");
2876
2877         private static void cursor_cluster_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2878         {
2879             Eina.Log.Debug("function efl_text_cursor_cluster_prev was called");
2880             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2881             if (ws != null)
2882             {
2883
2884                 try
2885                 {
2886                     ((LayoutPartText)ws.Target).CursorClusterPrev(cur);
2887                 }
2888                 catch (Exception e)
2889                 {
2890                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2891                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2892                 }
2893
2894
2895             }
2896             else
2897             {
2898                 efl_text_cursor_cluster_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2899             }
2900         }
2901
2902         private static efl_text_cursor_cluster_prev_delegate efl_text_cursor_cluster_prev_static_delegate;
2903
2904
2905         private delegate void efl_text_cursor_paragraph_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2906
2907
2908         public delegate void efl_text_cursor_paragraph_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2909
2910         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_first_api_delegate> efl_text_cursor_paragraph_char_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_first_api_delegate>(Module, "efl_text_cursor_paragraph_char_first");
2911
2912         private static void cursor_paragraph_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2913         {
2914             Eina.Log.Debug("function efl_text_cursor_paragraph_char_first was called");
2915             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2916             if (ws != null)
2917             {
2918
2919                 try
2920                 {
2921                     ((LayoutPartText)ws.Target).CursorParagraphCharFirst(cur);
2922                 }
2923                 catch (Exception e)
2924                 {
2925                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2926                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2927                 }
2928
2929
2930             }
2931             else
2932             {
2933                 efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2934             }
2935         }
2936
2937         private static efl_text_cursor_paragraph_char_first_delegate efl_text_cursor_paragraph_char_first_static_delegate;
2938
2939
2940         private delegate void efl_text_cursor_paragraph_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2941
2942
2943         public delegate void efl_text_cursor_paragraph_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2944
2945         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_last_api_delegate> efl_text_cursor_paragraph_char_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_last_api_delegate>(Module, "efl_text_cursor_paragraph_char_last");
2946
2947         private static void cursor_paragraph_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2948         {
2949             Eina.Log.Debug("function efl_text_cursor_paragraph_char_last was called");
2950             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2951             if (ws != null)
2952             {
2953
2954                 try
2955                 {
2956                     ((LayoutPartText)ws.Target).CursorParagraphCharLast(cur);
2957                 }
2958                 catch (Exception e)
2959                 {
2960                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2961                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2962                 }
2963
2964
2965             }
2966             else
2967             {
2968                 efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2969             }
2970         }
2971
2972         private static efl_text_cursor_paragraph_char_last_delegate efl_text_cursor_paragraph_char_last_static_delegate;
2973
2974
2975         private delegate void efl_text_cursor_word_start_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2976
2977
2978         public delegate void efl_text_cursor_word_start_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2979
2980         public static Efl.Eo.FunctionWrapper<efl_text_cursor_word_start_api_delegate> efl_text_cursor_word_start_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_word_start_api_delegate>(Module, "efl_text_cursor_word_start");
2981
2982         private static void cursor_word_start(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2983         {
2984             Eina.Log.Debug("function efl_text_cursor_word_start was called");
2985             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2986             if (ws != null)
2987             {
2988
2989                 try
2990                 {
2991                     ((LayoutPartText)ws.Target).CursorWordStart(cur);
2992                 }
2993                 catch (Exception e)
2994                 {
2995                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2996                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2997                 }
2998
2999
3000             }
3001             else
3002             {
3003                 efl_text_cursor_word_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3004             }
3005         }
3006
3007         private static efl_text_cursor_word_start_delegate efl_text_cursor_word_start_static_delegate;
3008
3009
3010         private delegate void efl_text_cursor_word_end_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3011
3012
3013         public delegate void efl_text_cursor_word_end_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3014
3015         public static Efl.Eo.FunctionWrapper<efl_text_cursor_word_end_api_delegate> efl_text_cursor_word_end_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_word_end_api_delegate>(Module, "efl_text_cursor_word_end");
3016
3017         private static void cursor_word_end(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3018         {
3019             Eina.Log.Debug("function efl_text_cursor_word_end was called");
3020             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3021             if (ws != null)
3022             {
3023
3024                 try
3025                 {
3026                     ((LayoutPartText)ws.Target).CursorWordEnd(cur);
3027                 }
3028                 catch (Exception e)
3029                 {
3030                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3031                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3032                 }
3033
3034
3035             }
3036             else
3037             {
3038                 efl_text_cursor_word_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3039             }
3040         }
3041
3042         private static efl_text_cursor_word_end_delegate efl_text_cursor_word_end_static_delegate;
3043
3044
3045         private delegate void efl_text_cursor_line_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3046
3047
3048         public delegate void efl_text_cursor_line_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3049
3050         public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_first_api_delegate> efl_text_cursor_line_char_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_first_api_delegate>(Module, "efl_text_cursor_line_char_first");
3051
3052         private static void cursor_line_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3053         {
3054             Eina.Log.Debug("function efl_text_cursor_line_char_first was called");
3055             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3056             if (ws != null)
3057             {
3058
3059                 try
3060                 {
3061                     ((LayoutPartText)ws.Target).CursorLineCharFirst(cur);
3062                 }
3063                 catch (Exception e)
3064                 {
3065                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3066                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3067                 }
3068
3069
3070             }
3071             else
3072             {
3073                 efl_text_cursor_line_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3074             }
3075         }
3076
3077         private static efl_text_cursor_line_char_first_delegate efl_text_cursor_line_char_first_static_delegate;
3078
3079
3080         private delegate void efl_text_cursor_line_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3081
3082
3083         public delegate void efl_text_cursor_line_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3084
3085         public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_last_api_delegate> efl_text_cursor_line_char_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_last_api_delegate>(Module, "efl_text_cursor_line_char_last");
3086
3087         private static void cursor_line_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3088         {
3089             Eina.Log.Debug("function efl_text_cursor_line_char_last was called");
3090             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3091             if (ws != null)
3092             {
3093
3094                 try
3095                 {
3096                     ((LayoutPartText)ws.Target).CursorLineCharLast(cur);
3097                 }
3098                 catch (Exception e)
3099                 {
3100                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3101                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3102                 }
3103
3104
3105             }
3106             else
3107             {
3108                 efl_text_cursor_line_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3109             }
3110         }
3111
3112         private static efl_text_cursor_line_char_last_delegate efl_text_cursor_line_char_last_static_delegate;
3113
3114
3115         private delegate void efl_text_cursor_paragraph_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3116
3117
3118         public delegate void efl_text_cursor_paragraph_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3119
3120         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_first_api_delegate> efl_text_cursor_paragraph_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_first_api_delegate>(Module, "efl_text_cursor_paragraph_first");
3121
3122         private static void cursor_paragraph_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3123         {
3124             Eina.Log.Debug("function efl_text_cursor_paragraph_first was called");
3125             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3126             if (ws != null)
3127             {
3128
3129                 try
3130                 {
3131                     ((LayoutPartText)ws.Target).CursorParagraphFirst(cur);
3132                 }
3133                 catch (Exception e)
3134                 {
3135                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3136                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3137                 }
3138
3139
3140             }
3141             else
3142             {
3143                 efl_text_cursor_paragraph_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3144             }
3145         }
3146
3147         private static efl_text_cursor_paragraph_first_delegate efl_text_cursor_paragraph_first_static_delegate;
3148
3149
3150         private delegate void efl_text_cursor_paragraph_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3151
3152
3153         public delegate void efl_text_cursor_paragraph_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3154
3155         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_last_api_delegate> efl_text_cursor_paragraph_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_last_api_delegate>(Module, "efl_text_cursor_paragraph_last");
3156
3157         private static void cursor_paragraph_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3158         {
3159             Eina.Log.Debug("function efl_text_cursor_paragraph_last was called");
3160             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3161             if (ws != null)
3162             {
3163
3164                 try
3165                 {
3166                     ((LayoutPartText)ws.Target).CursorParagraphLast(cur);
3167                 }
3168                 catch (Exception e)
3169                 {
3170                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3171                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3172                 }
3173
3174
3175             }
3176             else
3177             {
3178                 efl_text_cursor_paragraph_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3179             }
3180         }
3181
3182         private static efl_text_cursor_paragraph_last_delegate efl_text_cursor_paragraph_last_static_delegate;
3183
3184
3185         private delegate void efl_text_cursor_paragraph_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3186
3187
3188         public delegate void efl_text_cursor_paragraph_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3189
3190         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_next_api_delegate> efl_text_cursor_paragraph_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_next_api_delegate>(Module, "efl_text_cursor_paragraph_next");
3191
3192         private static void cursor_paragraph_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3193         {
3194             Eina.Log.Debug("function efl_text_cursor_paragraph_next was called");
3195             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3196             if (ws != null)
3197             {
3198
3199                 try
3200                 {
3201                     ((LayoutPartText)ws.Target).CursorParagraphNext(cur);
3202                 }
3203                 catch (Exception e)
3204                 {
3205                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3206                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3207                 }
3208
3209
3210             }
3211             else
3212             {
3213                 efl_text_cursor_paragraph_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3214             }
3215         }
3216
3217         private static efl_text_cursor_paragraph_next_delegate efl_text_cursor_paragraph_next_static_delegate;
3218
3219
3220         private delegate void efl_text_cursor_paragraph_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3221
3222
3223         public delegate void efl_text_cursor_paragraph_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3224
3225         public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_prev_api_delegate> efl_text_cursor_paragraph_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_prev_api_delegate>(Module, "efl_text_cursor_paragraph_prev");
3226
3227         private static void cursor_paragraph_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3228         {
3229             Eina.Log.Debug("function efl_text_cursor_paragraph_prev was called");
3230             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3231             if (ws != null)
3232             {
3233
3234                 try
3235                 {
3236                     ((LayoutPartText)ws.Target).CursorParagraphPrev(cur);
3237                 }
3238                 catch (Exception e)
3239                 {
3240                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3241                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3242                 }
3243
3244
3245             }
3246             else
3247             {
3248                 efl_text_cursor_paragraph_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3249             }
3250         }
3251
3252         private static efl_text_cursor_paragraph_prev_delegate efl_text_cursor_paragraph_prev_static_delegate;
3253
3254
3255         private delegate void efl_text_cursor_line_jump_by_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int by);
3256
3257
3258         public delegate void efl_text_cursor_line_jump_by_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int by);
3259
3260         public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_jump_by_api_delegate> efl_text_cursor_line_jump_by_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_jump_by_api_delegate>(Module, "efl_text_cursor_line_jump_by");
3261
3262         private static void cursor_line_jump_by(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int by)
3263         {
3264             Eina.Log.Debug("function efl_text_cursor_line_jump_by was called");
3265             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3266             if (ws != null)
3267             {
3268
3269                 try
3270                 {
3271                     ((LayoutPartText)ws.Target).CursorLineJumpBy(cur, by);
3272                 }
3273                 catch (Exception e)
3274                 {
3275                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3276                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3277                 }
3278
3279
3280             }
3281             else
3282             {
3283                 efl_text_cursor_line_jump_by_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, by);
3284             }
3285         }
3286
3287         private static efl_text_cursor_line_jump_by_delegate efl_text_cursor_line_jump_by_static_delegate;
3288
3289
3290         private delegate void efl_text_cursor_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
3291
3292
3293         public delegate void efl_text_cursor_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
3294
3295         public static Efl.Eo.FunctionWrapper<efl_text_cursor_coord_set_api_delegate> efl_text_cursor_coord_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_coord_set_api_delegate>(Module, "efl_text_cursor_coord_set");
3296
3297         private static void cursor_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
3298         {
3299             Eina.Log.Debug("function efl_text_cursor_coord_set was called");
3300             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3301             if (ws != null)
3302             {
3303
3304                 try
3305                 {
3306                     ((LayoutPartText)ws.Target).SetCursorCoord(cur, x, y);
3307                 }
3308                 catch (Exception e)
3309                 {
3310                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3311                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3312                 }
3313
3314
3315             }
3316             else
3317             {
3318                 efl_text_cursor_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
3319             }
3320         }
3321
3322         private static efl_text_cursor_coord_set_delegate efl_text_cursor_coord_set_static_delegate;
3323
3324
3325         private delegate void efl_text_cursor_cluster_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
3326
3327
3328         public delegate void efl_text_cursor_cluster_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
3329
3330         public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_coord_set_api_delegate> efl_text_cursor_cluster_coord_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_coord_set_api_delegate>(Module, "efl_text_cursor_cluster_coord_set");
3331
3332         private static void cursor_cluster_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
3333         {
3334             Eina.Log.Debug("function efl_text_cursor_cluster_coord_set was called");
3335             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3336             if (ws != null)
3337             {
3338
3339                 try
3340                 {
3341                     ((LayoutPartText)ws.Target).SetCursorClusterCoord(cur, x, y);
3342                 }
3343                 catch (Exception e)
3344                 {
3345                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3346                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3347                 }
3348
3349
3350             }
3351             else
3352             {
3353                 efl_text_cursor_cluster_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
3354             }
3355         }
3356
3357         private static efl_text_cursor_cluster_coord_set_delegate efl_text_cursor_cluster_coord_set_static_delegate;
3358
3359
3360         private delegate int efl_text_cursor_text_insert_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
3361
3362
3363         public delegate int efl_text_cursor_text_insert_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
3364
3365         public static Efl.Eo.FunctionWrapper<efl_text_cursor_text_insert_api_delegate> efl_text_cursor_text_insert_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_text_insert_api_delegate>(Module, "efl_text_cursor_text_insert");
3366
3367         private static int cursor_text_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String text)
3368         {
3369             Eina.Log.Debug("function efl_text_cursor_text_insert was called");
3370             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3371             if (ws != null)
3372             {
3373                                                             int _ret_var = default(int);
3374                 try
3375                 {
3376                     _ret_var = ((LayoutPartText)ws.Target).CursorTextInsert(cur, text);
3377                 }
3378                 catch (Exception e)
3379                 {
3380                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3381                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3382                 }
3383
3384                                         return _ret_var;
3385
3386             }
3387             else
3388             {
3389                 return efl_text_cursor_text_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, text);
3390             }
3391         }
3392
3393         private static efl_text_cursor_text_insert_delegate efl_text_cursor_text_insert_static_delegate;
3394
3395
3396         private delegate void efl_text_cursor_char_delete_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3397
3398
3399         public delegate void efl_text_cursor_char_delete_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3400
3401         public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_delete_api_delegate> efl_text_cursor_char_delete_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_delete_api_delegate>(Module, "efl_text_cursor_char_delete");
3402
3403         private static void cursor_char_delete(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3404         {
3405             Eina.Log.Debug("function efl_text_cursor_char_delete was called");
3406             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3407             if (ws != null)
3408             {
3409
3410                 try
3411                 {
3412                     ((LayoutPartText)ws.Target).CursorCharDelete(cur);
3413                 }
3414                 catch (Exception e)
3415                 {
3416                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3417                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3418                 }
3419
3420
3421             }
3422             else
3423             {
3424                 efl_text_cursor_char_delete_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3425             }
3426         }
3427
3428         private static efl_text_cursor_char_delete_delegate efl_text_cursor_char_delete_static_delegate;
3429
3430
3431         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);
3432
3433
3434         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);
3435
3436         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");
3437
3438         private static void font_get(System.IntPtr obj, System.IntPtr pd, out System.String font, out Efl.Font.Size size)
3439         {
3440             Eina.Log.Debug("function efl_text_font_get was called");
3441             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3442             if (ws != null)
3443             {
3444                         System.String _out_font = default(System.String);
3445         size = default(Efl.Font.Size);
3446                 try
3447                 {
3448                     ((LayoutPartText)ws.Target).GetFont(out _out_font, out size);
3449                 }
3450                 catch (Exception e)
3451                 {
3452                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3453                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3454                 }
3455
3456         font = _out_font;
3457
3458             }
3459             else
3460             {
3461                 efl_text_font_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out font, out size);
3462             }
3463         }
3464
3465         private static efl_text_font_get_delegate efl_text_font_get_static_delegate;
3466
3467
3468         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);
3469
3470
3471         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);
3472
3473         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");
3474
3475         private static void font_set(System.IntPtr obj, System.IntPtr pd, System.String font, Efl.Font.Size size)
3476         {
3477             Eina.Log.Debug("function efl_text_font_set was called");
3478             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3479             if (ws != null)
3480             {
3481
3482                 try
3483                 {
3484                     ((LayoutPartText)ws.Target).SetFont(font, size);
3485                 }
3486                 catch (Exception e)
3487                 {
3488                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3489                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3490                 }
3491
3492
3493             }
3494             else
3495             {
3496                 efl_text_font_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font, size);
3497             }
3498         }
3499
3500         private static efl_text_font_set_delegate efl_text_font_set_static_delegate;
3501
3502         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3503         private delegate System.String efl_text_font_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
3504
3505         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3506         public delegate System.String efl_text_font_source_get_api_delegate(System.IntPtr obj);
3507
3508         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");
3509
3510         private static System.String font_source_get(System.IntPtr obj, System.IntPtr pd)
3511         {
3512             Eina.Log.Debug("function efl_text_font_source_get was called");
3513             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3514             if (ws != null)
3515             {
3516             System.String _ret_var = default(System.String);
3517                 try
3518                 {
3519                     _ret_var = ((LayoutPartText)ws.Target).GetFontSource();
3520                 }
3521                 catch (Exception e)
3522                 {
3523                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3524                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3525                 }
3526
3527         return _ret_var;
3528
3529             }
3530             else
3531             {
3532                 return efl_text_font_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3533             }
3534         }
3535
3536         private static efl_text_font_source_get_delegate efl_text_font_source_get_static_delegate;
3537
3538
3539         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);
3540
3541
3542         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);
3543
3544         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");
3545
3546         private static void font_source_set(System.IntPtr obj, System.IntPtr pd, System.String font_source)
3547         {
3548             Eina.Log.Debug("function efl_text_font_source_set was called");
3549             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3550             if (ws != null)
3551             {
3552
3553                 try
3554                 {
3555                     ((LayoutPartText)ws.Target).SetFontSource(font_source);
3556                 }
3557                 catch (Exception e)
3558                 {
3559                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3560                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3561                 }
3562
3563
3564             }
3565             else
3566             {
3567                 efl_text_font_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_source);
3568             }
3569         }
3570
3571         private static efl_text_font_source_set_delegate efl_text_font_source_set_static_delegate;
3572
3573         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3574         private delegate System.String efl_text_font_fallbacks_get_delegate(System.IntPtr obj, System.IntPtr pd);
3575
3576         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3577         public delegate System.String efl_text_font_fallbacks_get_api_delegate(System.IntPtr obj);
3578
3579         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");
3580
3581         private static System.String font_fallbacks_get(System.IntPtr obj, System.IntPtr pd)
3582         {
3583             Eina.Log.Debug("function efl_text_font_fallbacks_get was called");
3584             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3585             if (ws != null)
3586             {
3587             System.String _ret_var = default(System.String);
3588                 try
3589                 {
3590                     _ret_var = ((LayoutPartText)ws.Target).GetFontFallbacks();
3591                 }
3592                 catch (Exception e)
3593                 {
3594                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3595                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3596                 }
3597
3598         return _ret_var;
3599
3600             }
3601             else
3602             {
3603                 return efl_text_font_fallbacks_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3604             }
3605         }
3606
3607         private static efl_text_font_fallbacks_get_delegate efl_text_font_fallbacks_get_static_delegate;
3608
3609
3610         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);
3611
3612
3613         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);
3614
3615         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");
3616
3617         private static void font_fallbacks_set(System.IntPtr obj, System.IntPtr pd, System.String font_fallbacks)
3618         {
3619             Eina.Log.Debug("function efl_text_font_fallbacks_set was called");
3620             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3621             if (ws != null)
3622             {
3623
3624                 try
3625                 {
3626                     ((LayoutPartText)ws.Target).SetFontFallbacks(font_fallbacks);
3627                 }
3628                 catch (Exception e)
3629                 {
3630                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3631                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3632                 }
3633
3634
3635             }
3636             else
3637             {
3638                 efl_text_font_fallbacks_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_fallbacks);
3639             }
3640         }
3641
3642         private static efl_text_font_fallbacks_set_delegate efl_text_font_fallbacks_set_static_delegate;
3643
3644
3645         private delegate Efl.TextFontWeight efl_text_font_weight_get_delegate(System.IntPtr obj, System.IntPtr pd);
3646
3647
3648         public delegate Efl.TextFontWeight efl_text_font_weight_get_api_delegate(System.IntPtr obj);
3649
3650         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");
3651
3652         private static Efl.TextFontWeight font_weight_get(System.IntPtr obj, System.IntPtr pd)
3653         {
3654             Eina.Log.Debug("function efl_text_font_weight_get was called");
3655             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3656             if (ws != null)
3657             {
3658             Efl.TextFontWeight _ret_var = default(Efl.TextFontWeight);
3659                 try
3660                 {
3661                     _ret_var = ((LayoutPartText)ws.Target).GetFontWeight();
3662                 }
3663                 catch (Exception e)
3664                 {
3665                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3666                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3667                 }
3668
3669         return _ret_var;
3670
3671             }
3672             else
3673             {
3674                 return efl_text_font_weight_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3675             }
3676         }
3677
3678         private static efl_text_font_weight_get_delegate efl_text_font_weight_get_static_delegate;
3679
3680
3681         private delegate void efl_text_font_weight_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWeight font_weight);
3682
3683
3684         public delegate void efl_text_font_weight_set_api_delegate(System.IntPtr obj,  Efl.TextFontWeight font_weight);
3685
3686         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");
3687
3688         private static void font_weight_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWeight font_weight)
3689         {
3690             Eina.Log.Debug("function efl_text_font_weight_set was called");
3691             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3692             if (ws != null)
3693             {
3694
3695                 try
3696                 {
3697                     ((LayoutPartText)ws.Target).SetFontWeight(font_weight);
3698                 }
3699                 catch (Exception e)
3700                 {
3701                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3702                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3703                 }
3704
3705
3706             }
3707             else
3708             {
3709                 efl_text_font_weight_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), font_weight);
3710             }
3711         }
3712
3713         private static efl_text_font_weight_set_delegate efl_text_font_weight_set_static_delegate;
3714
3715
3716         private delegate Efl.TextFontSlant efl_text_font_slant_get_delegate(System.IntPtr obj, System.IntPtr pd);
3717
3718
3719         public delegate Efl.TextFontSlant efl_text_font_slant_get_api_delegate(System.IntPtr obj);
3720
3721         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");
3722
3723         private static Efl.TextFontSlant font_slant_get(System.IntPtr obj, System.IntPtr pd)
3724         {
3725             Eina.Log.Debug("function efl_text_font_slant_get was called");
3726             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3727             if (ws != null)
3728             {
3729             Efl.TextFontSlant _ret_var = default(Efl.TextFontSlant);
3730                 try
3731                 {
3732                     _ret_var = ((LayoutPartText)ws.Target).GetFontSlant();
3733                 }
3734                 catch (Exception e)
3735                 {
3736                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3737                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3738                 }
3739
3740         return _ret_var;
3741
3742             }
3743             else
3744             {
3745                 return efl_text_font_slant_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3746             }
3747         }
3748
3749         private static efl_text_font_slant_get_delegate efl_text_font_slant_get_static_delegate;
3750
3751
3752         private delegate void efl_text_font_slant_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontSlant style);
3753
3754
3755         public delegate void efl_text_font_slant_set_api_delegate(System.IntPtr obj,  Efl.TextFontSlant style);
3756
3757         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");
3758
3759         private static void font_slant_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontSlant style)
3760         {
3761             Eina.Log.Debug("function efl_text_font_slant_set was called");
3762             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3763             if (ws != null)
3764             {
3765
3766                 try
3767                 {
3768                     ((LayoutPartText)ws.Target).SetFontSlant(style);
3769                 }
3770                 catch (Exception e)
3771                 {
3772                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3773                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3774                 }
3775
3776
3777             }
3778             else
3779             {
3780                 efl_text_font_slant_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), style);
3781             }
3782         }
3783
3784         private static efl_text_font_slant_set_delegate efl_text_font_slant_set_static_delegate;
3785
3786
3787         private delegate Efl.TextFontWidth efl_text_font_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
3788
3789
3790         public delegate Efl.TextFontWidth efl_text_font_width_get_api_delegate(System.IntPtr obj);
3791
3792         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");
3793
3794         private static Efl.TextFontWidth font_width_get(System.IntPtr obj, System.IntPtr pd)
3795         {
3796             Eina.Log.Debug("function efl_text_font_width_get was called");
3797             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3798             if (ws != null)
3799             {
3800             Efl.TextFontWidth _ret_var = default(Efl.TextFontWidth);
3801                 try
3802                 {
3803                     _ret_var = ((LayoutPartText)ws.Target).GetFontWidth();
3804                 }
3805                 catch (Exception e)
3806                 {
3807                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3808                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3809                 }
3810
3811         return _ret_var;
3812
3813             }
3814             else
3815             {
3816                 return efl_text_font_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3817             }
3818         }
3819
3820         private static efl_text_font_width_get_delegate efl_text_font_width_get_static_delegate;
3821
3822
3823         private delegate void efl_text_font_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontWidth width);
3824
3825
3826         public delegate void efl_text_font_width_set_api_delegate(System.IntPtr obj,  Efl.TextFontWidth width);
3827
3828         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");
3829
3830         private static void font_width_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontWidth width)
3831         {
3832             Eina.Log.Debug("function efl_text_font_width_set was called");
3833             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3834             if (ws != null)
3835             {
3836
3837                 try
3838                 {
3839                     ((LayoutPartText)ws.Target).SetFontWidth(width);
3840                 }
3841                 catch (Exception e)
3842                 {
3843                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3844                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3845                 }
3846
3847
3848             }
3849             else
3850             {
3851                 efl_text_font_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
3852             }
3853         }
3854
3855         private static efl_text_font_width_set_delegate efl_text_font_width_set_static_delegate;
3856
3857         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3858         private delegate System.String efl_text_font_lang_get_delegate(System.IntPtr obj, System.IntPtr pd);
3859
3860         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3861         public delegate System.String efl_text_font_lang_get_api_delegate(System.IntPtr obj);
3862
3863         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");
3864
3865         private static System.String font_lang_get(System.IntPtr obj, System.IntPtr pd)
3866         {
3867             Eina.Log.Debug("function efl_text_font_lang_get was called");
3868             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3869             if (ws != null)
3870             {
3871             System.String _ret_var = default(System.String);
3872                 try
3873                 {
3874                     _ret_var = ((LayoutPartText)ws.Target).GetFontLang();
3875                 }
3876                 catch (Exception e)
3877                 {
3878                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3879                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3880                 }
3881
3882         return _ret_var;
3883
3884             }
3885             else
3886             {
3887                 return efl_text_font_lang_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3888             }
3889         }
3890
3891         private static efl_text_font_lang_get_delegate efl_text_font_lang_get_static_delegate;
3892
3893
3894         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);
3895
3896
3897         public delegate void efl_text_font_lang_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String lang);
3898
3899         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");
3900
3901         private static void font_lang_set(System.IntPtr obj, System.IntPtr pd, System.String lang)
3902         {
3903             Eina.Log.Debug("function efl_text_font_lang_set was called");
3904             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3905             if (ws != null)
3906             {
3907
3908                 try
3909                 {
3910                     ((LayoutPartText)ws.Target).SetFontLang(lang);
3911                 }
3912                 catch (Exception e)
3913                 {
3914                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3915                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3916                 }
3917
3918
3919             }
3920             else
3921             {
3922                 efl_text_font_lang_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), lang);
3923             }
3924         }
3925
3926         private static efl_text_font_lang_set_delegate efl_text_font_lang_set_static_delegate;
3927
3928
3929         private delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_delegate(System.IntPtr obj, System.IntPtr pd);
3930
3931
3932         public delegate Efl.TextFontBitmapScalable efl_text_font_bitmap_scalable_get_api_delegate(System.IntPtr obj);
3933
3934         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");
3935
3936         private static Efl.TextFontBitmapScalable font_bitmap_scalable_get(System.IntPtr obj, System.IntPtr pd)
3937         {
3938             Eina.Log.Debug("function efl_text_font_bitmap_scalable_get was called");
3939             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3940             if (ws != null)
3941             {
3942             Efl.TextFontBitmapScalable _ret_var = default(Efl.TextFontBitmapScalable);
3943                 try
3944                 {
3945                     _ret_var = ((LayoutPartText)ws.Target).GetFontBitmapScalable();
3946                 }
3947                 catch (Exception e)
3948                 {
3949                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3950                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3951                 }
3952
3953         return _ret_var;
3954
3955             }
3956             else
3957             {
3958                 return efl_text_font_bitmap_scalable_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3959             }
3960         }
3961
3962         private static efl_text_font_bitmap_scalable_get_delegate efl_text_font_bitmap_scalable_get_static_delegate;
3963
3964
3965         private delegate void efl_text_font_bitmap_scalable_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFontBitmapScalable scalable);
3966
3967
3968         public delegate void efl_text_font_bitmap_scalable_set_api_delegate(System.IntPtr obj,  Efl.TextFontBitmapScalable scalable);
3969
3970         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");
3971
3972         private static void font_bitmap_scalable_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFontBitmapScalable scalable)
3973         {
3974             Eina.Log.Debug("function efl_text_font_bitmap_scalable_set was called");
3975             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3976             if (ws != null)
3977             {
3978
3979                 try
3980                 {
3981                     ((LayoutPartText)ws.Target).SetFontBitmapScalable(scalable);
3982                 }
3983                 catch (Exception e)
3984                 {
3985                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3986                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3987                 }
3988
3989
3990             }
3991             else
3992             {
3993                 efl_text_font_bitmap_scalable_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scalable);
3994             }
3995         }
3996
3997         private static efl_text_font_bitmap_scalable_set_delegate efl_text_font_bitmap_scalable_set_static_delegate;
3998
3999
4000         private delegate double efl_text_ellipsis_get_delegate(System.IntPtr obj, System.IntPtr pd);
4001
4002
4003         public delegate double efl_text_ellipsis_get_api_delegate(System.IntPtr obj);
4004
4005         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");
4006
4007         private static double ellipsis_get(System.IntPtr obj, System.IntPtr pd)
4008         {
4009             Eina.Log.Debug("function efl_text_ellipsis_get was called");
4010             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4011             if (ws != null)
4012             {
4013             double _ret_var = default(double);
4014                 try
4015                 {
4016                     _ret_var = ((LayoutPartText)ws.Target).GetEllipsis();
4017                 }
4018                 catch (Exception e)
4019                 {
4020                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4021                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4022                 }
4023
4024         return _ret_var;
4025
4026             }
4027             else
4028             {
4029                 return efl_text_ellipsis_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4030             }
4031         }
4032
4033         private static efl_text_ellipsis_get_delegate efl_text_ellipsis_get_static_delegate;
4034
4035
4036         private delegate void efl_text_ellipsis_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
4037
4038
4039         public delegate void efl_text_ellipsis_set_api_delegate(System.IntPtr obj,  double value);
4040
4041         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");
4042
4043         private static void ellipsis_set(System.IntPtr obj, System.IntPtr pd, double value)
4044         {
4045             Eina.Log.Debug("function efl_text_ellipsis_set was called");
4046             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4047             if (ws != null)
4048             {
4049
4050                 try
4051                 {
4052                     ((LayoutPartText)ws.Target).SetEllipsis(value);
4053                 }
4054                 catch (Exception e)
4055                 {
4056                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4057                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4058                 }
4059
4060
4061             }
4062             else
4063             {
4064                 efl_text_ellipsis_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4065             }
4066         }
4067
4068         private static efl_text_ellipsis_set_delegate efl_text_ellipsis_set_static_delegate;
4069
4070
4071         private delegate Efl.TextFormatWrap efl_text_wrap_get_delegate(System.IntPtr obj, System.IntPtr pd);
4072
4073
4074         public delegate Efl.TextFormatWrap efl_text_wrap_get_api_delegate(System.IntPtr obj);
4075
4076         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");
4077
4078         private static Efl.TextFormatWrap wrap_get(System.IntPtr obj, System.IntPtr pd)
4079         {
4080             Eina.Log.Debug("function efl_text_wrap_get was called");
4081             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4082             if (ws != null)
4083             {
4084             Efl.TextFormatWrap _ret_var = default(Efl.TextFormatWrap);
4085                 try
4086                 {
4087                     _ret_var = ((LayoutPartText)ws.Target).GetWrap();
4088                 }
4089                 catch (Exception e)
4090                 {
4091                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4092                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4093                 }
4094
4095         return _ret_var;
4096
4097             }
4098             else
4099             {
4100                 return efl_text_wrap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4101             }
4102         }
4103
4104         private static efl_text_wrap_get_delegate efl_text_wrap_get_static_delegate;
4105
4106
4107         private delegate void efl_text_wrap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatWrap wrap);
4108
4109
4110         public delegate void efl_text_wrap_set_api_delegate(System.IntPtr obj,  Efl.TextFormatWrap wrap);
4111
4112         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");
4113
4114         private static void wrap_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatWrap wrap)
4115         {
4116             Eina.Log.Debug("function efl_text_wrap_set was called");
4117             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4118             if (ws != null)
4119             {
4120
4121                 try
4122                 {
4123                     ((LayoutPartText)ws.Target).SetWrap(wrap);
4124                 }
4125                 catch (Exception e)
4126                 {
4127                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4128                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4129                 }
4130
4131
4132             }
4133             else
4134             {
4135                 efl_text_wrap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), wrap);
4136             }
4137         }
4138
4139         private static efl_text_wrap_set_delegate efl_text_wrap_set_static_delegate;
4140
4141         [return: MarshalAs(UnmanagedType.U1)]
4142         private delegate bool efl_text_multiline_get_delegate(System.IntPtr obj, System.IntPtr pd);
4143
4144         [return: MarshalAs(UnmanagedType.U1)]
4145         public delegate bool efl_text_multiline_get_api_delegate(System.IntPtr obj);
4146
4147         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");
4148
4149         private static bool multiline_get(System.IntPtr obj, System.IntPtr pd)
4150         {
4151             Eina.Log.Debug("function efl_text_multiline_get was called");
4152             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4153             if (ws != null)
4154             {
4155             bool _ret_var = default(bool);
4156                 try
4157                 {
4158                     _ret_var = ((LayoutPartText)ws.Target).GetMultiline();
4159                 }
4160                 catch (Exception e)
4161                 {
4162                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4163                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4164                 }
4165
4166         return _ret_var;
4167
4168             }
4169             else
4170             {
4171                 return efl_text_multiline_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4172             }
4173         }
4174
4175         private static efl_text_multiline_get_delegate efl_text_multiline_get_static_delegate;
4176
4177
4178         private delegate void efl_text_multiline_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
4179
4180
4181         public delegate void efl_text_multiline_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
4182
4183         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");
4184
4185         private static void multiline_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
4186         {
4187             Eina.Log.Debug("function efl_text_multiline_set was called");
4188             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4189             if (ws != null)
4190             {
4191
4192                 try
4193                 {
4194                     ((LayoutPartText)ws.Target).SetMultiline(enabled);
4195                 }
4196                 catch (Exception e)
4197                 {
4198                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4199                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4200                 }
4201
4202
4203             }
4204             else
4205             {
4206                 efl_text_multiline_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
4207             }
4208         }
4209
4210         private static efl_text_multiline_set_delegate efl_text_multiline_set_static_delegate;
4211
4212
4213         private delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
4214
4215
4216         public delegate Efl.TextFormatHorizontalAlignmentAutoType efl_text_halign_auto_type_get_api_delegate(System.IntPtr obj);
4217
4218         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");
4219
4220         private static Efl.TextFormatHorizontalAlignmentAutoType halign_auto_type_get(System.IntPtr obj, System.IntPtr pd)
4221         {
4222             Eina.Log.Debug("function efl_text_halign_auto_type_get was called");
4223             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4224             if (ws != null)
4225             {
4226             Efl.TextFormatHorizontalAlignmentAutoType _ret_var = default(Efl.TextFormatHorizontalAlignmentAutoType);
4227                 try
4228                 {
4229                     _ret_var = ((LayoutPartText)ws.Target).GetHalignAutoType();
4230                 }
4231                 catch (Exception e)
4232                 {
4233                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4234                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4235                 }
4236
4237         return _ret_var;
4238
4239             }
4240             else
4241             {
4242                 return efl_text_halign_auto_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4243             }
4244         }
4245
4246         private static efl_text_halign_auto_type_get_delegate efl_text_halign_auto_type_get_static_delegate;
4247
4248
4249         private delegate void efl_text_halign_auto_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextFormatHorizontalAlignmentAutoType value);
4250
4251
4252         public delegate void efl_text_halign_auto_type_set_api_delegate(System.IntPtr obj,  Efl.TextFormatHorizontalAlignmentAutoType value);
4253
4254         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");
4255
4256         private static void halign_auto_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextFormatHorizontalAlignmentAutoType value)
4257         {
4258             Eina.Log.Debug("function efl_text_halign_auto_type_set was called");
4259             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4260             if (ws != null)
4261             {
4262
4263                 try
4264                 {
4265                     ((LayoutPartText)ws.Target).SetHalignAutoType(value);
4266                 }
4267                 catch (Exception e)
4268                 {
4269                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4270                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4271                 }
4272
4273
4274             }
4275             else
4276             {
4277                 efl_text_halign_auto_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4278             }
4279         }
4280
4281         private static efl_text_halign_auto_type_set_delegate efl_text_halign_auto_type_set_static_delegate;
4282
4283
4284         private delegate double efl_text_halign_get_delegate(System.IntPtr obj, System.IntPtr pd);
4285
4286
4287         public delegate double efl_text_halign_get_api_delegate(System.IntPtr obj);
4288
4289         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");
4290
4291         private static double halign_get(System.IntPtr obj, System.IntPtr pd)
4292         {
4293             Eina.Log.Debug("function efl_text_halign_get was called");
4294             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4295             if (ws != null)
4296             {
4297             double _ret_var = default(double);
4298                 try
4299                 {
4300                     _ret_var = ((LayoutPartText)ws.Target).GetHalign();
4301                 }
4302                 catch (Exception e)
4303                 {
4304                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4305                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4306                 }
4307
4308         return _ret_var;
4309
4310             }
4311             else
4312             {
4313                 return efl_text_halign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4314             }
4315         }
4316
4317         private static efl_text_halign_get_delegate efl_text_halign_get_static_delegate;
4318
4319
4320         private delegate void efl_text_halign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
4321
4322
4323         public delegate void efl_text_halign_set_api_delegate(System.IntPtr obj,  double value);
4324
4325         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");
4326
4327         private static void halign_set(System.IntPtr obj, System.IntPtr pd, double value)
4328         {
4329             Eina.Log.Debug("function efl_text_halign_set was called");
4330             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4331             if (ws != null)
4332             {
4333
4334                 try
4335                 {
4336                     ((LayoutPartText)ws.Target).SetHalign(value);
4337                 }
4338                 catch (Exception e)
4339                 {
4340                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4341                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4342                 }
4343
4344
4345             }
4346             else
4347             {
4348                 efl_text_halign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4349             }
4350         }
4351
4352         private static efl_text_halign_set_delegate efl_text_halign_set_static_delegate;
4353
4354
4355         private delegate double efl_text_valign_get_delegate(System.IntPtr obj, System.IntPtr pd);
4356
4357
4358         public delegate double efl_text_valign_get_api_delegate(System.IntPtr obj);
4359
4360         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");
4361
4362         private static double valign_get(System.IntPtr obj, System.IntPtr pd)
4363         {
4364             Eina.Log.Debug("function efl_text_valign_get was called");
4365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4366             if (ws != null)
4367             {
4368             double _ret_var = default(double);
4369                 try
4370                 {
4371                     _ret_var = ((LayoutPartText)ws.Target).GetValign();
4372                 }
4373                 catch (Exception e)
4374                 {
4375                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4376                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4377                 }
4378
4379         return _ret_var;
4380
4381             }
4382             else
4383             {
4384                 return efl_text_valign_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4385             }
4386         }
4387
4388         private static efl_text_valign_get_delegate efl_text_valign_get_static_delegate;
4389
4390
4391         private delegate void efl_text_valign_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
4392
4393
4394         public delegate void efl_text_valign_set_api_delegate(System.IntPtr obj,  double value);
4395
4396         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");
4397
4398         private static void valign_set(System.IntPtr obj, System.IntPtr pd, double value)
4399         {
4400             Eina.Log.Debug("function efl_text_valign_set was called");
4401             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4402             if (ws != null)
4403             {
4404
4405                 try
4406                 {
4407                     ((LayoutPartText)ws.Target).SetValign(value);
4408                 }
4409                 catch (Exception e)
4410                 {
4411                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4412                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4413                 }
4414
4415
4416             }
4417             else
4418             {
4419                 efl_text_valign_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4420             }
4421         }
4422
4423         private static efl_text_valign_set_delegate efl_text_valign_set_static_delegate;
4424
4425
4426         private delegate double efl_text_linegap_get_delegate(System.IntPtr obj, System.IntPtr pd);
4427
4428
4429         public delegate double efl_text_linegap_get_api_delegate(System.IntPtr obj);
4430
4431         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");
4432
4433         private static double linegap_get(System.IntPtr obj, System.IntPtr pd)
4434         {
4435             Eina.Log.Debug("function efl_text_linegap_get was called");
4436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4437             if (ws != null)
4438             {
4439             double _ret_var = default(double);
4440                 try
4441                 {
4442                     _ret_var = ((LayoutPartText)ws.Target).GetLinegap();
4443                 }
4444                 catch (Exception e)
4445                 {
4446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4448                 }
4449
4450         return _ret_var;
4451
4452             }
4453             else
4454             {
4455                 return efl_text_linegap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4456             }
4457         }
4458
4459         private static efl_text_linegap_get_delegate efl_text_linegap_get_static_delegate;
4460
4461
4462         private delegate void efl_text_linegap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
4463
4464
4465         public delegate void efl_text_linegap_set_api_delegate(System.IntPtr obj,  double value);
4466
4467         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");
4468
4469         private static void linegap_set(System.IntPtr obj, System.IntPtr pd, double value)
4470         {
4471             Eina.Log.Debug("function efl_text_linegap_set was called");
4472             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4473             if (ws != null)
4474             {
4475
4476                 try
4477                 {
4478                     ((LayoutPartText)ws.Target).SetLinegap(value);
4479                 }
4480                 catch (Exception e)
4481                 {
4482                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4483                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4484                 }
4485
4486
4487             }
4488             else
4489             {
4490                 efl_text_linegap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4491             }
4492         }
4493
4494         private static efl_text_linegap_set_delegate efl_text_linegap_set_static_delegate;
4495
4496
4497         private delegate double efl_text_linerelgap_get_delegate(System.IntPtr obj, System.IntPtr pd);
4498
4499
4500         public delegate double efl_text_linerelgap_get_api_delegate(System.IntPtr obj);
4501
4502         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");
4503
4504         private static double linerelgap_get(System.IntPtr obj, System.IntPtr pd)
4505         {
4506             Eina.Log.Debug("function efl_text_linerelgap_get was called");
4507             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4508             if (ws != null)
4509             {
4510             double _ret_var = default(double);
4511                 try
4512                 {
4513                     _ret_var = ((LayoutPartText)ws.Target).GetLinerelgap();
4514                 }
4515                 catch (Exception e)
4516                 {
4517                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4518                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4519                 }
4520
4521         return _ret_var;
4522
4523             }
4524             else
4525             {
4526                 return efl_text_linerelgap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4527             }
4528         }
4529
4530         private static efl_text_linerelgap_get_delegate efl_text_linerelgap_get_static_delegate;
4531
4532
4533         private delegate void efl_text_linerelgap_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value);
4534
4535
4536         public delegate void efl_text_linerelgap_set_api_delegate(System.IntPtr obj,  double value);
4537
4538         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");
4539
4540         private static void linerelgap_set(System.IntPtr obj, System.IntPtr pd, double value)
4541         {
4542             Eina.Log.Debug("function efl_text_linerelgap_set was called");
4543             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4544             if (ws != null)
4545             {
4546
4547                 try
4548                 {
4549                     ((LayoutPartText)ws.Target).SetLinerelgap(value);
4550                 }
4551                 catch (Exception e)
4552                 {
4553                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4554                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4555                 }
4556
4557
4558             }
4559             else
4560             {
4561                 efl_text_linerelgap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4562             }
4563         }
4564
4565         private static efl_text_linerelgap_set_delegate efl_text_linerelgap_set_static_delegate;
4566
4567
4568         private delegate int efl_text_tabstops_get_delegate(System.IntPtr obj, System.IntPtr pd);
4569
4570
4571         public delegate int efl_text_tabstops_get_api_delegate(System.IntPtr obj);
4572
4573         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");
4574
4575         private static int tabstops_get(System.IntPtr obj, System.IntPtr pd)
4576         {
4577             Eina.Log.Debug("function efl_text_tabstops_get was called");
4578             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4579             if (ws != null)
4580             {
4581             int _ret_var = default(int);
4582                 try
4583                 {
4584                     _ret_var = ((LayoutPartText)ws.Target).GetTabstops();
4585                 }
4586                 catch (Exception e)
4587                 {
4588                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4589                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4590                 }
4591
4592         return _ret_var;
4593
4594             }
4595             else
4596             {
4597                 return efl_text_tabstops_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4598             }
4599         }
4600
4601         private static efl_text_tabstops_get_delegate efl_text_tabstops_get_static_delegate;
4602
4603
4604         private delegate void efl_text_tabstops_set_delegate(System.IntPtr obj, System.IntPtr pd,  int value);
4605
4606
4607         public delegate void efl_text_tabstops_set_api_delegate(System.IntPtr obj,  int value);
4608
4609         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");
4610
4611         private static void tabstops_set(System.IntPtr obj, System.IntPtr pd, int value)
4612         {
4613             Eina.Log.Debug("function efl_text_tabstops_set was called");
4614             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4615             if (ws != null)
4616             {
4617
4618                 try
4619                 {
4620                     ((LayoutPartText)ws.Target).SetTabstops(value);
4621                 }
4622                 catch (Exception e)
4623                 {
4624                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4625                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4626                 }
4627
4628
4629             }
4630             else
4631             {
4632                 efl_text_tabstops_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
4633             }
4634         }
4635
4636         private static efl_text_tabstops_set_delegate efl_text_tabstops_set_static_delegate;
4637
4638         [return: MarshalAs(UnmanagedType.U1)]
4639         private delegate bool efl_text_password_get_delegate(System.IntPtr obj, System.IntPtr pd);
4640
4641         [return: MarshalAs(UnmanagedType.U1)]
4642         public delegate bool efl_text_password_get_api_delegate(System.IntPtr obj);
4643
4644         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");
4645
4646         private static bool password_get(System.IntPtr obj, System.IntPtr pd)
4647         {
4648             Eina.Log.Debug("function efl_text_password_get was called");
4649             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4650             if (ws != null)
4651             {
4652             bool _ret_var = default(bool);
4653                 try
4654                 {
4655                     _ret_var = ((LayoutPartText)ws.Target).GetPassword();
4656                 }
4657                 catch (Exception e)
4658                 {
4659                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4660                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4661                 }
4662
4663         return _ret_var;
4664
4665             }
4666             else
4667             {
4668                 return efl_text_password_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4669             }
4670         }
4671
4672         private static efl_text_password_get_delegate efl_text_password_get_static_delegate;
4673
4674
4675         private delegate void efl_text_password_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enabled);
4676
4677
4678         public delegate void efl_text_password_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enabled);
4679
4680         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");
4681
4682         private static void password_set(System.IntPtr obj, System.IntPtr pd, bool enabled)
4683         {
4684             Eina.Log.Debug("function efl_text_password_set was called");
4685             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4686             if (ws != null)
4687             {
4688
4689                 try
4690                 {
4691                     ((LayoutPartText)ws.Target).SetPassword(enabled);
4692                 }
4693                 catch (Exception e)
4694                 {
4695                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4696                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4697                 }
4698
4699
4700             }
4701             else
4702             {
4703                 efl_text_password_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enabled);
4704             }
4705         }
4706
4707         private static efl_text_password_set_delegate efl_text_password_set_static_delegate;
4708
4709         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4710         private delegate System.String efl_text_replacement_char_get_delegate(System.IntPtr obj, System.IntPtr pd);
4711
4712         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4713         public delegate System.String efl_text_replacement_char_get_api_delegate(System.IntPtr obj);
4714
4715         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");
4716
4717         private static System.String replacement_char_get(System.IntPtr obj, System.IntPtr pd)
4718         {
4719             Eina.Log.Debug("function efl_text_replacement_char_get was called");
4720             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4721             if (ws != null)
4722             {
4723             System.String _ret_var = default(System.String);
4724                 try
4725                 {
4726                     _ret_var = ((LayoutPartText)ws.Target).GetReplacementChar();
4727                 }
4728                 catch (Exception e)
4729                 {
4730                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4731                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4732                 }
4733
4734         return _ret_var;
4735
4736             }
4737             else
4738             {
4739                 return efl_text_replacement_char_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4740             }
4741         }
4742
4743         private static efl_text_replacement_char_get_delegate efl_text_replacement_char_get_static_delegate;
4744
4745
4746         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);
4747
4748
4749         public delegate void efl_text_replacement_char_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String repch);
4750
4751         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");
4752
4753         private static void replacement_char_set(System.IntPtr obj, System.IntPtr pd, System.String repch)
4754         {
4755             Eina.Log.Debug("function efl_text_replacement_char_set was called");
4756             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4757             if (ws != null)
4758             {
4759
4760                 try
4761                 {
4762                     ((LayoutPartText)ws.Target).SetReplacementChar(repch);
4763                 }
4764                 catch (Exception e)
4765                 {
4766                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4767                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4768                 }
4769
4770
4771             }
4772             else
4773             {
4774                 efl_text_replacement_char_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), repch);
4775             }
4776         }
4777
4778         private static efl_text_replacement_char_set_delegate efl_text_replacement_char_set_static_delegate;
4779
4780         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4781         private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
4782
4783         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
4784         public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
4785
4786         public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
4787
4788         private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
4789         {
4790             Eina.Log.Debug("function efl_text_markup_get was called");
4791             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4792             if (ws != null)
4793             {
4794             System.String _ret_var = default(System.String);
4795                 try
4796                 {
4797                     _ret_var = ((LayoutPartText)ws.Target).GetMarkup();
4798                 }
4799                 catch (Exception e)
4800                 {
4801                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4802                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4803                 }
4804
4805         return _ret_var;
4806
4807             }
4808             else
4809             {
4810                 return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4811             }
4812         }
4813
4814         private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
4815
4816
4817         private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
4818
4819
4820         public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
4821
4822         public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
4823
4824         private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
4825         {
4826             Eina.Log.Debug("function efl_text_markup_set was called");
4827             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4828             if (ws != null)
4829             {
4830
4831                 try
4832                 {
4833                     ((LayoutPartText)ws.Target).SetMarkup(markup);
4834                 }
4835                 catch (Exception e)
4836                 {
4837                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4838                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4839                 }
4840
4841
4842             }
4843             else
4844             {
4845                 efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
4846             }
4847         }
4848
4849         private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
4850
4851         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
4852         private delegate System.String efl_text_markup_interactive_markup_range_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
4853
4854         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
4855         public delegate System.String efl_text_markup_interactive_markup_range_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
4856
4857         public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_get_api_delegate> efl_text_markup_interactive_markup_range_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_get_api_delegate>(Module, "efl_text_markup_interactive_markup_range_get");
4858
4859         private static System.String markup_range_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end)
4860         {
4861             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_get was called");
4862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4863             if (ws != null)
4864             {
4865                                                             System.String _ret_var = default(System.String);
4866                 try
4867                 {
4868                     _ret_var = ((LayoutPartText)ws.Target).GetMarkupRange(start, end);
4869                 }
4870                 catch (Exception e)
4871                 {
4872                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4873                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4874                 }
4875
4876                                         return _ret_var;
4877
4878             }
4879             else
4880             {
4881                 return efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, end);
4882             }
4883         }
4884
4885         private static efl_text_markup_interactive_markup_range_get_delegate efl_text_markup_interactive_markup_range_get_static_delegate;
4886
4887
4888         private delegate void efl_text_markup_interactive_markup_range_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] System.String markup);
4889
4890
4891         public delegate void efl_text_markup_interactive_markup_range_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] System.String markup);
4892
4893         public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_set_api_delegate> efl_text_markup_interactive_markup_range_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_set_api_delegate>(Module, "efl_text_markup_interactive_markup_range_set");
4894
4895         private static void markup_range_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup)
4896         {
4897             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_set was called");
4898             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4899             if (ws != null)
4900             {
4901
4902                 try
4903                 {
4904                     ((LayoutPartText)ws.Target).SetMarkupRange(start, end, markup);
4905                 }
4906                 catch (Exception e)
4907                 {
4908                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4909                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4910                 }
4911
4912
4913             }
4914             else
4915             {
4916                 efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, end, markup);
4917             }
4918         }
4919
4920         private static efl_text_markup_interactive_markup_range_set_delegate efl_text_markup_interactive_markup_range_set_static_delegate;
4921
4922
4923         private delegate void efl_text_markup_interactive_cursor_markup_insert_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
4924
4925
4926         public delegate void efl_text_markup_interactive_cursor_markup_insert_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
4927
4928         public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_cursor_markup_insert_api_delegate> efl_text_markup_interactive_cursor_markup_insert_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_cursor_markup_insert_api_delegate>(Module, "efl_text_markup_interactive_cursor_markup_insert");
4929
4930         private static void cursor_markup_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String markup)
4931         {
4932             Eina.Log.Debug("function efl_text_markup_interactive_cursor_markup_insert was called");
4933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4934             if (ws != null)
4935             {
4936
4937                 try
4938                 {
4939                     ((LayoutPartText)ws.Target).CursorMarkupInsert(cur, markup);
4940                 }
4941                 catch (Exception e)
4942                 {
4943                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4944                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4945                 }
4946
4947
4948             }
4949             else
4950             {
4951                 efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, markup);
4952             }
4953         }
4954
4955         private static efl_text_markup_interactive_cursor_markup_insert_delegate efl_text_markup_interactive_cursor_markup_insert_static_delegate;
4956
4957
4958         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);
4959
4960
4961         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);
4962
4963         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");
4964
4965         private static void normal_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
4966         {
4967             Eina.Log.Debug("function efl_text_normal_color_get was called");
4968             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
4969             if (ws != null)
4970             {
4971                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
4972                 try
4973                 {
4974                     ((LayoutPartText)ws.Target).GetNormalColor(out r, out g, out b, out a);
4975                 }
4976                 catch (Exception e)
4977                 {
4978                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4979                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4980                 }
4981
4982
4983             }
4984             else
4985             {
4986                 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);
4987             }
4988         }
4989
4990         private static efl_text_normal_color_get_delegate efl_text_normal_color_get_static_delegate;
4991
4992
4993         private delegate void efl_text_normal_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
4994
4995
4996         public delegate void efl_text_normal_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
4997
4998         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");
4999
5000         private static void normal_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5001         {
5002             Eina.Log.Debug("function efl_text_normal_color_set was called");
5003             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5004             if (ws != null)
5005             {
5006
5007                 try
5008                 {
5009                     ((LayoutPartText)ws.Target).SetNormalColor(r, g, b, a);
5010                 }
5011                 catch (Exception e)
5012                 {
5013                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5014                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5015                 }
5016
5017
5018             }
5019             else
5020             {
5021                 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);
5022             }
5023         }
5024
5025         private static efl_text_normal_color_set_delegate efl_text_normal_color_set_static_delegate;
5026
5027
5028         private delegate Efl.TextStyleBackingType efl_text_backing_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
5029
5030
5031         public delegate Efl.TextStyleBackingType efl_text_backing_type_get_api_delegate(System.IntPtr obj);
5032
5033         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");
5034
5035         private static Efl.TextStyleBackingType backing_type_get(System.IntPtr obj, System.IntPtr pd)
5036         {
5037             Eina.Log.Debug("function efl_text_backing_type_get was called");
5038             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5039             if (ws != null)
5040             {
5041             Efl.TextStyleBackingType _ret_var = default(Efl.TextStyleBackingType);
5042                 try
5043                 {
5044                     _ret_var = ((LayoutPartText)ws.Target).GetBackingType();
5045                 }
5046                 catch (Exception e)
5047                 {
5048                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5049                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5050                 }
5051
5052         return _ret_var;
5053
5054             }
5055             else
5056             {
5057                 return efl_text_backing_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5058             }
5059         }
5060
5061         private static efl_text_backing_type_get_delegate efl_text_backing_type_get_static_delegate;
5062
5063
5064         private delegate void efl_text_backing_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleBackingType type);
5065
5066
5067         public delegate void efl_text_backing_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleBackingType type);
5068
5069         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");
5070
5071         private static void backing_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleBackingType type)
5072         {
5073             Eina.Log.Debug("function efl_text_backing_type_set was called");
5074             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5075             if (ws != null)
5076             {
5077
5078                 try
5079                 {
5080                     ((LayoutPartText)ws.Target).SetBackingType(type);
5081                 }
5082                 catch (Exception e)
5083                 {
5084                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5085                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5086                 }
5087
5088
5089             }
5090             else
5091             {
5092                 efl_text_backing_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
5093             }
5094         }
5095
5096         private static efl_text_backing_type_set_delegate efl_text_backing_type_set_static_delegate;
5097
5098
5099         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);
5100
5101
5102         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);
5103
5104         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");
5105
5106         private static void backing_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
5107         {
5108             Eina.Log.Debug("function efl_text_backing_color_get was called");
5109             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5110             if (ws != null)
5111             {
5112                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5113                 try
5114                 {
5115                     ((LayoutPartText)ws.Target).GetBackingColor(out r, out g, out b, out a);
5116                 }
5117                 catch (Exception e)
5118                 {
5119                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5120                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5121                 }
5122
5123
5124             }
5125             else
5126             {
5127                 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);
5128             }
5129         }
5130
5131         private static efl_text_backing_color_get_delegate efl_text_backing_color_get_static_delegate;
5132
5133
5134         private delegate void efl_text_backing_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5135
5136
5137         public delegate void efl_text_backing_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5138
5139         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");
5140
5141         private static void backing_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5142         {
5143             Eina.Log.Debug("function efl_text_backing_color_set was called");
5144             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5145             if (ws != null)
5146             {
5147
5148                 try
5149                 {
5150                     ((LayoutPartText)ws.Target).SetBackingColor(r, g, b, a);
5151                 }
5152                 catch (Exception e)
5153                 {
5154                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5155                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5156                 }
5157
5158
5159             }
5160             else
5161             {
5162                 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);
5163             }
5164         }
5165
5166         private static efl_text_backing_color_set_delegate efl_text_backing_color_set_static_delegate;
5167
5168
5169         private delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
5170
5171
5172         public delegate Efl.TextStyleUnderlineType efl_text_underline_type_get_api_delegate(System.IntPtr obj);
5173
5174         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");
5175
5176         private static Efl.TextStyleUnderlineType underline_type_get(System.IntPtr obj, System.IntPtr pd)
5177         {
5178             Eina.Log.Debug("function efl_text_underline_type_get was called");
5179             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5180             if (ws != null)
5181             {
5182             Efl.TextStyleUnderlineType _ret_var = default(Efl.TextStyleUnderlineType);
5183                 try
5184                 {
5185                     _ret_var = ((LayoutPartText)ws.Target).GetUnderlineType();
5186                 }
5187                 catch (Exception e)
5188                 {
5189                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5190                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5191                 }
5192
5193         return _ret_var;
5194
5195             }
5196             else
5197             {
5198                 return efl_text_underline_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5199             }
5200         }
5201
5202         private static efl_text_underline_type_get_delegate efl_text_underline_type_get_static_delegate;
5203
5204
5205         private delegate void efl_text_underline_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleUnderlineType type);
5206
5207
5208         public delegate void efl_text_underline_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleUnderlineType type);
5209
5210         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");
5211
5212         private static void underline_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleUnderlineType type)
5213         {
5214             Eina.Log.Debug("function efl_text_underline_type_set was called");
5215             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5216             if (ws != null)
5217             {
5218
5219                 try
5220                 {
5221                     ((LayoutPartText)ws.Target).SetUnderlineType(type);
5222                 }
5223                 catch (Exception e)
5224                 {
5225                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5226                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5227                 }
5228
5229
5230             }
5231             else
5232             {
5233                 efl_text_underline_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
5234             }
5235         }
5236
5237         private static efl_text_underline_type_set_delegate efl_text_underline_type_set_static_delegate;
5238
5239
5240         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);
5241
5242
5243         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);
5244
5245         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");
5246
5247         private static void underline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
5248         {
5249             Eina.Log.Debug("function efl_text_underline_color_get was called");
5250             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5251             if (ws != null)
5252             {
5253                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5254                 try
5255                 {
5256                     ((LayoutPartText)ws.Target).GetUnderlineColor(out r, out g, out b, out a);
5257                 }
5258                 catch (Exception e)
5259                 {
5260                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5261                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5262                 }
5263
5264
5265             }
5266             else
5267             {
5268                 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);
5269             }
5270         }
5271
5272         private static efl_text_underline_color_get_delegate efl_text_underline_color_get_static_delegate;
5273
5274
5275         private delegate void efl_text_underline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5276
5277
5278         public delegate void efl_text_underline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5279
5280         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");
5281
5282         private static void underline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5283         {
5284             Eina.Log.Debug("function efl_text_underline_color_set was called");
5285             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5286             if (ws != null)
5287             {
5288
5289                 try
5290                 {
5291                     ((LayoutPartText)ws.Target).SetUnderlineColor(r, g, b, a);
5292                 }
5293                 catch (Exception e)
5294                 {
5295                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5296                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5297                 }
5298
5299
5300             }
5301             else
5302             {
5303                 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);
5304             }
5305         }
5306
5307         private static efl_text_underline_color_set_delegate efl_text_underline_color_set_static_delegate;
5308
5309
5310         private delegate double efl_text_underline_height_get_delegate(System.IntPtr obj, System.IntPtr pd);
5311
5312
5313         public delegate double efl_text_underline_height_get_api_delegate(System.IntPtr obj);
5314
5315         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");
5316
5317         private static double underline_height_get(System.IntPtr obj, System.IntPtr pd)
5318         {
5319             Eina.Log.Debug("function efl_text_underline_height_get was called");
5320             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5321             if (ws != null)
5322             {
5323             double _ret_var = default(double);
5324                 try
5325                 {
5326                     _ret_var = ((LayoutPartText)ws.Target).GetUnderlineHeight();
5327                 }
5328                 catch (Exception e)
5329                 {
5330                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5331                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5332                 }
5333
5334         return _ret_var;
5335
5336             }
5337             else
5338             {
5339                 return efl_text_underline_height_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5340             }
5341         }
5342
5343         private static efl_text_underline_height_get_delegate efl_text_underline_height_get_static_delegate;
5344
5345
5346         private delegate void efl_text_underline_height_set_delegate(System.IntPtr obj, System.IntPtr pd,  double height);
5347
5348
5349         public delegate void efl_text_underline_height_set_api_delegate(System.IntPtr obj,  double height);
5350
5351         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");
5352
5353         private static void underline_height_set(System.IntPtr obj, System.IntPtr pd, double height)
5354         {
5355             Eina.Log.Debug("function efl_text_underline_height_set was called");
5356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5357             if (ws != null)
5358             {
5359
5360                 try
5361                 {
5362                     ((LayoutPartText)ws.Target).SetUnderlineHeight(height);
5363                 }
5364                 catch (Exception e)
5365                 {
5366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5368                 }
5369
5370
5371             }
5372             else
5373             {
5374                 efl_text_underline_height_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), height);
5375             }
5376         }
5377
5378         private static efl_text_underline_height_set_delegate efl_text_underline_height_set_static_delegate;
5379
5380
5381         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);
5382
5383
5384         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);
5385
5386         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");
5387
5388         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)
5389         {
5390             Eina.Log.Debug("function efl_text_underline_dashed_color_get was called");
5391             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5392             if (ws != null)
5393             {
5394                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5395                 try
5396                 {
5397                     ((LayoutPartText)ws.Target).GetUnderlineDashedColor(out r, out g, out b, out a);
5398                 }
5399                 catch (Exception e)
5400                 {
5401                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5402                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5403                 }
5404
5405
5406             }
5407             else
5408             {
5409                 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);
5410             }
5411         }
5412
5413         private static efl_text_underline_dashed_color_get_delegate efl_text_underline_dashed_color_get_static_delegate;
5414
5415
5416         private delegate void efl_text_underline_dashed_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5417
5418
5419         public delegate void efl_text_underline_dashed_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5420
5421         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");
5422
5423         private static void underline_dashed_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5424         {
5425             Eina.Log.Debug("function efl_text_underline_dashed_color_set was called");
5426             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5427             if (ws != null)
5428             {
5429
5430                 try
5431                 {
5432                     ((LayoutPartText)ws.Target).SetUnderlineDashedColor(r, g, b, a);
5433                 }
5434                 catch (Exception e)
5435                 {
5436                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5437                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5438                 }
5439
5440
5441             }
5442             else
5443             {
5444                 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);
5445             }
5446         }
5447
5448         private static efl_text_underline_dashed_color_set_delegate efl_text_underline_dashed_color_set_static_delegate;
5449
5450
5451         private delegate int efl_text_underline_dashed_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
5452
5453
5454         public delegate int efl_text_underline_dashed_width_get_api_delegate(System.IntPtr obj);
5455
5456         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");
5457
5458         private static int underline_dashed_width_get(System.IntPtr obj, System.IntPtr pd)
5459         {
5460             Eina.Log.Debug("function efl_text_underline_dashed_width_get was called");
5461             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5462             if (ws != null)
5463             {
5464             int _ret_var = default(int);
5465                 try
5466                 {
5467                     _ret_var = ((LayoutPartText)ws.Target).GetUnderlineDashedWidth();
5468                 }
5469                 catch (Exception e)
5470                 {
5471                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5472                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5473                 }
5474
5475         return _ret_var;
5476
5477             }
5478             else
5479             {
5480                 return efl_text_underline_dashed_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5481             }
5482         }
5483
5484         private static efl_text_underline_dashed_width_get_delegate efl_text_underline_dashed_width_get_static_delegate;
5485
5486
5487         private delegate void efl_text_underline_dashed_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  int width);
5488
5489
5490         public delegate void efl_text_underline_dashed_width_set_api_delegate(System.IntPtr obj,  int width);
5491
5492         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");
5493
5494         private static void underline_dashed_width_set(System.IntPtr obj, System.IntPtr pd, int width)
5495         {
5496             Eina.Log.Debug("function efl_text_underline_dashed_width_set was called");
5497             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5498             if (ws != null)
5499             {
5500
5501                 try
5502                 {
5503                     ((LayoutPartText)ws.Target).SetUnderlineDashedWidth(width);
5504                 }
5505                 catch (Exception e)
5506                 {
5507                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5508                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5509                 }
5510
5511
5512             }
5513             else
5514             {
5515                 efl_text_underline_dashed_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), width);
5516             }
5517         }
5518
5519         private static efl_text_underline_dashed_width_set_delegate efl_text_underline_dashed_width_set_static_delegate;
5520
5521
5522         private delegate int efl_text_underline_dashed_gap_get_delegate(System.IntPtr obj, System.IntPtr pd);
5523
5524
5525         public delegate int efl_text_underline_dashed_gap_get_api_delegate(System.IntPtr obj);
5526
5527         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");
5528
5529         private static int underline_dashed_gap_get(System.IntPtr obj, System.IntPtr pd)
5530         {
5531             Eina.Log.Debug("function efl_text_underline_dashed_gap_get was called");
5532             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5533             if (ws != null)
5534             {
5535             int _ret_var = default(int);
5536                 try
5537                 {
5538                     _ret_var = ((LayoutPartText)ws.Target).GetUnderlineDashedGap();
5539                 }
5540                 catch (Exception e)
5541                 {
5542                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5543                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5544                 }
5545
5546         return _ret_var;
5547
5548             }
5549             else
5550             {
5551                 return efl_text_underline_dashed_gap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5552             }
5553         }
5554
5555         private static efl_text_underline_dashed_gap_get_delegate efl_text_underline_dashed_gap_get_static_delegate;
5556
5557
5558         private delegate void efl_text_underline_dashed_gap_set_delegate(System.IntPtr obj, System.IntPtr pd,  int gap);
5559
5560
5561         public delegate void efl_text_underline_dashed_gap_set_api_delegate(System.IntPtr obj,  int gap);
5562
5563         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");
5564
5565         private static void underline_dashed_gap_set(System.IntPtr obj, System.IntPtr pd, int gap)
5566         {
5567             Eina.Log.Debug("function efl_text_underline_dashed_gap_set was called");
5568             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5569             if (ws != null)
5570             {
5571
5572                 try
5573                 {
5574                     ((LayoutPartText)ws.Target).SetUnderlineDashedGap(gap);
5575                 }
5576                 catch (Exception e)
5577                 {
5578                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5579                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5580                 }
5581
5582
5583             }
5584             else
5585             {
5586                 efl_text_underline_dashed_gap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gap);
5587             }
5588         }
5589
5590         private static efl_text_underline_dashed_gap_set_delegate efl_text_underline_dashed_gap_set_static_delegate;
5591
5592
5593         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);
5594
5595
5596         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);
5597
5598         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");
5599
5600         private static void underline2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
5601         {
5602             Eina.Log.Debug("function efl_text_underline2_color_get was called");
5603             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5604             if (ws != null)
5605             {
5606                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5607                 try
5608                 {
5609                     ((LayoutPartText)ws.Target).GetUnderline2Color(out r, out g, out b, out a);
5610                 }
5611                 catch (Exception e)
5612                 {
5613                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5614                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5615                 }
5616
5617
5618             }
5619             else
5620             {
5621                 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);
5622             }
5623         }
5624
5625         private static efl_text_underline2_color_get_delegate efl_text_underline2_color_get_static_delegate;
5626
5627
5628         private delegate void efl_text_underline2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5629
5630
5631         public delegate void efl_text_underline2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5632
5633         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");
5634
5635         private static void underline2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5636         {
5637             Eina.Log.Debug("function efl_text_underline2_color_set was called");
5638             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5639             if (ws != null)
5640             {
5641
5642                 try
5643                 {
5644                     ((LayoutPartText)ws.Target).SetUnderline2Color(r, g, b, a);
5645                 }
5646                 catch (Exception e)
5647                 {
5648                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5649                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5650                 }
5651
5652
5653             }
5654             else
5655             {
5656                 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);
5657             }
5658         }
5659
5660         private static efl_text_underline2_color_set_delegate efl_text_underline2_color_set_static_delegate;
5661
5662
5663         private delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
5664
5665
5666         public delegate Efl.TextStyleStrikethroughType efl_text_strikethrough_type_get_api_delegate(System.IntPtr obj);
5667
5668         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");
5669
5670         private static Efl.TextStyleStrikethroughType strikethrough_type_get(System.IntPtr obj, System.IntPtr pd)
5671         {
5672             Eina.Log.Debug("function efl_text_strikethrough_type_get was called");
5673             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5674             if (ws != null)
5675             {
5676             Efl.TextStyleStrikethroughType _ret_var = default(Efl.TextStyleStrikethroughType);
5677                 try
5678                 {
5679                     _ret_var = ((LayoutPartText)ws.Target).GetStrikethroughType();
5680                 }
5681                 catch (Exception e)
5682                 {
5683                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5684                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5685                 }
5686
5687         return _ret_var;
5688
5689             }
5690             else
5691             {
5692                 return efl_text_strikethrough_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5693             }
5694         }
5695
5696         private static efl_text_strikethrough_type_get_delegate efl_text_strikethrough_type_get_static_delegate;
5697
5698
5699         private delegate void efl_text_strikethrough_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleStrikethroughType type);
5700
5701
5702         public delegate void efl_text_strikethrough_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleStrikethroughType type);
5703
5704         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");
5705
5706         private static void strikethrough_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleStrikethroughType type)
5707         {
5708             Eina.Log.Debug("function efl_text_strikethrough_type_set was called");
5709             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5710             if (ws != null)
5711             {
5712
5713                 try
5714                 {
5715                     ((LayoutPartText)ws.Target).SetStrikethroughType(type);
5716                 }
5717                 catch (Exception e)
5718                 {
5719                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5720                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5721                 }
5722
5723
5724             }
5725             else
5726             {
5727                 efl_text_strikethrough_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
5728             }
5729         }
5730
5731         private static efl_text_strikethrough_type_set_delegate efl_text_strikethrough_type_set_static_delegate;
5732
5733
5734         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);
5735
5736
5737         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);
5738
5739         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");
5740
5741         private static void strikethrough_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
5742         {
5743             Eina.Log.Debug("function efl_text_strikethrough_color_get was called");
5744             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5745             if (ws != null)
5746             {
5747                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5748                 try
5749                 {
5750                     ((LayoutPartText)ws.Target).GetStrikethroughColor(out r, out g, out b, out a);
5751                 }
5752                 catch (Exception e)
5753                 {
5754                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5755                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5756                 }
5757
5758
5759             }
5760             else
5761             {
5762                 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);
5763             }
5764         }
5765
5766         private static efl_text_strikethrough_color_get_delegate efl_text_strikethrough_color_get_static_delegate;
5767
5768
5769         private delegate void efl_text_strikethrough_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5770
5771
5772         public delegate void efl_text_strikethrough_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5773
5774         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");
5775
5776         private static void strikethrough_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5777         {
5778             Eina.Log.Debug("function efl_text_strikethrough_color_set was called");
5779             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5780             if (ws != null)
5781             {
5782
5783                 try
5784                 {
5785                     ((LayoutPartText)ws.Target).SetStrikethroughColor(r, g, b, a);
5786                 }
5787                 catch (Exception e)
5788                 {
5789                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5790                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5791                 }
5792
5793
5794             }
5795             else
5796             {
5797                 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);
5798             }
5799         }
5800
5801         private static efl_text_strikethrough_color_set_delegate efl_text_strikethrough_color_set_static_delegate;
5802
5803
5804         private delegate Efl.TextStyleEffectType efl_text_effect_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
5805
5806
5807         public delegate Efl.TextStyleEffectType efl_text_effect_type_get_api_delegate(System.IntPtr obj);
5808
5809         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");
5810
5811         private static Efl.TextStyleEffectType effect_type_get(System.IntPtr obj, System.IntPtr pd)
5812         {
5813             Eina.Log.Debug("function efl_text_effect_type_get was called");
5814             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5815             if (ws != null)
5816             {
5817             Efl.TextStyleEffectType _ret_var = default(Efl.TextStyleEffectType);
5818                 try
5819                 {
5820                     _ret_var = ((LayoutPartText)ws.Target).GetEffectType();
5821                 }
5822                 catch (Exception e)
5823                 {
5824                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5825                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5826                 }
5827
5828         return _ret_var;
5829
5830             }
5831             else
5832             {
5833                 return efl_text_effect_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5834             }
5835         }
5836
5837         private static efl_text_effect_type_get_delegate efl_text_effect_type_get_static_delegate;
5838
5839
5840         private delegate void efl_text_effect_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleEffectType type);
5841
5842
5843         public delegate void efl_text_effect_type_set_api_delegate(System.IntPtr obj,  Efl.TextStyleEffectType type);
5844
5845         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");
5846
5847         private static void effect_type_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleEffectType type)
5848         {
5849             Eina.Log.Debug("function efl_text_effect_type_set was called");
5850             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5851             if (ws != null)
5852             {
5853
5854                 try
5855                 {
5856                     ((LayoutPartText)ws.Target).SetEffectType(type);
5857                 }
5858                 catch (Exception e)
5859                 {
5860                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5861                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5862                 }
5863
5864
5865             }
5866             else
5867             {
5868                 efl_text_effect_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
5869             }
5870         }
5871
5872         private static efl_text_effect_type_set_delegate efl_text_effect_type_set_static_delegate;
5873
5874
5875         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);
5876
5877
5878         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);
5879
5880         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");
5881
5882         private static void outline_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
5883         {
5884             Eina.Log.Debug("function efl_text_outline_color_get was called");
5885             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5886             if (ws != null)
5887             {
5888                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
5889                 try
5890                 {
5891                     ((LayoutPartText)ws.Target).GetOutlineColor(out r, out g, out b, out a);
5892                 }
5893                 catch (Exception e)
5894                 {
5895                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5896                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5897                 }
5898
5899
5900             }
5901             else
5902             {
5903                 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);
5904             }
5905         }
5906
5907         private static efl_text_outline_color_get_delegate efl_text_outline_color_get_static_delegate;
5908
5909
5910         private delegate void efl_text_outline_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
5911
5912
5913         public delegate void efl_text_outline_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
5914
5915         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");
5916
5917         private static void outline_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
5918         {
5919             Eina.Log.Debug("function efl_text_outline_color_set was called");
5920             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5921             if (ws != null)
5922             {
5923
5924                 try
5925                 {
5926                     ((LayoutPartText)ws.Target).SetOutlineColor(r, g, b, a);
5927                 }
5928                 catch (Exception e)
5929                 {
5930                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5931                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5932                 }
5933
5934
5935             }
5936             else
5937             {
5938                 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);
5939             }
5940         }
5941
5942         private static efl_text_outline_color_set_delegate efl_text_outline_color_set_static_delegate;
5943
5944
5945         private delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
5946
5947
5948         public delegate Efl.TextStyleShadowDirection efl_text_shadow_direction_get_api_delegate(System.IntPtr obj);
5949
5950         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");
5951
5952         private static Efl.TextStyleShadowDirection shadow_direction_get(System.IntPtr obj, System.IntPtr pd)
5953         {
5954             Eina.Log.Debug("function efl_text_shadow_direction_get was called");
5955             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5956             if (ws != null)
5957             {
5958             Efl.TextStyleShadowDirection _ret_var = default(Efl.TextStyleShadowDirection);
5959                 try
5960                 {
5961                     _ret_var = ((LayoutPartText)ws.Target).GetShadowDirection();
5962                 }
5963                 catch (Exception e)
5964                 {
5965                     Eina.Log.Warning($"Callback error: {e.ToString()}");
5966                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
5967                 }
5968
5969         return _ret_var;
5970
5971             }
5972             else
5973             {
5974                 return efl_text_shadow_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
5975             }
5976         }
5977
5978         private static efl_text_shadow_direction_get_delegate efl_text_shadow_direction_get_static_delegate;
5979
5980
5981         private delegate void efl_text_shadow_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextStyleShadowDirection type);
5982
5983
5984         public delegate void efl_text_shadow_direction_set_api_delegate(System.IntPtr obj,  Efl.TextStyleShadowDirection type);
5985
5986         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");
5987
5988         private static void shadow_direction_set(System.IntPtr obj, System.IntPtr pd, Efl.TextStyleShadowDirection type)
5989         {
5990             Eina.Log.Debug("function efl_text_shadow_direction_set was called");
5991             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
5992             if (ws != null)
5993             {
5994
5995                 try
5996                 {
5997                     ((LayoutPartText)ws.Target).SetShadowDirection(type);
5998                 }
5999                 catch (Exception e)
6000                 {
6001                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6002                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6003                 }
6004
6005
6006             }
6007             else
6008             {
6009                 efl_text_shadow_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), type);
6010             }
6011         }
6012
6013         private static efl_text_shadow_direction_set_delegate efl_text_shadow_direction_set_static_delegate;
6014
6015
6016         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);
6017
6018
6019         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);
6020
6021         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");
6022
6023         private static void shadow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
6024         {
6025             Eina.Log.Debug("function efl_text_shadow_color_get was called");
6026             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6027             if (ws != null)
6028             {
6029                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
6030                 try
6031                 {
6032                     ((LayoutPartText)ws.Target).GetShadowColor(out r, out g, out b, out a);
6033                 }
6034                 catch (Exception e)
6035                 {
6036                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6037                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6038                 }
6039
6040
6041             }
6042             else
6043             {
6044                 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);
6045             }
6046         }
6047
6048         private static efl_text_shadow_color_get_delegate efl_text_shadow_color_get_static_delegate;
6049
6050
6051         private delegate void efl_text_shadow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
6052
6053
6054         public delegate void efl_text_shadow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
6055
6056         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");
6057
6058         private static void shadow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
6059         {
6060             Eina.Log.Debug("function efl_text_shadow_color_set was called");
6061             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6062             if (ws != null)
6063             {
6064
6065                 try
6066                 {
6067                     ((LayoutPartText)ws.Target).SetShadowColor(r, g, b, a);
6068                 }
6069                 catch (Exception e)
6070                 {
6071                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6072                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6073                 }
6074
6075
6076             }
6077             else
6078             {
6079                 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);
6080             }
6081         }
6082
6083         private static efl_text_shadow_color_set_delegate efl_text_shadow_color_set_static_delegate;
6084
6085
6086         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);
6087
6088
6089         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);
6090
6091         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");
6092
6093         private static void glow_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
6094         {
6095             Eina.Log.Debug("function efl_text_glow_color_get was called");
6096             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6097             if (ws != null)
6098             {
6099                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
6100                 try
6101                 {
6102                     ((LayoutPartText)ws.Target).GetGlowColor(out r, out g, out b, out a);
6103                 }
6104                 catch (Exception e)
6105                 {
6106                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6107                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6108                 }
6109
6110
6111             }
6112             else
6113             {
6114                 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);
6115             }
6116         }
6117
6118         private static efl_text_glow_color_get_delegate efl_text_glow_color_get_static_delegate;
6119
6120
6121         private delegate void efl_text_glow_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
6122
6123
6124         public delegate void efl_text_glow_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
6125
6126         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");
6127
6128         private static void glow_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
6129         {
6130             Eina.Log.Debug("function efl_text_glow_color_set was called");
6131             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6132             if (ws != null)
6133             {
6134
6135                 try
6136                 {
6137                     ((LayoutPartText)ws.Target).SetGlowColor(r, g, b, a);
6138                 }
6139                 catch (Exception e)
6140                 {
6141                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6142                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6143                 }
6144
6145
6146             }
6147             else
6148             {
6149                 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);
6150             }
6151         }
6152
6153         private static efl_text_glow_color_set_delegate efl_text_glow_color_set_static_delegate;
6154
6155
6156         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);
6157
6158
6159         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);
6160
6161         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");
6162
6163         private static void glow2_color_get(System.IntPtr obj, System.IntPtr pd, out byte r, out byte g, out byte b, out byte a)
6164         {
6165             Eina.Log.Debug("function efl_text_glow2_color_get was called");
6166             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6167             if (ws != null)
6168             {
6169                                         r = default(byte);        g = default(byte);        b = default(byte);        a = default(byte);
6170                 try
6171                 {
6172                     ((LayoutPartText)ws.Target).GetGlow2Color(out r, out g, out b, out a);
6173                 }
6174                 catch (Exception e)
6175                 {
6176                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6177                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6178                 }
6179
6180
6181             }
6182             else
6183             {
6184                 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);
6185             }
6186         }
6187
6188         private static efl_text_glow2_color_get_delegate efl_text_glow2_color_get_static_delegate;
6189
6190
6191         private delegate void efl_text_glow2_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  byte r,  byte g,  byte b,  byte a);
6192
6193
6194         public delegate void efl_text_glow2_color_set_api_delegate(System.IntPtr obj,  byte r,  byte g,  byte b,  byte a);
6195
6196         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");
6197
6198         private static void glow2_color_set(System.IntPtr obj, System.IntPtr pd, byte r, byte g, byte b, byte a)
6199         {
6200             Eina.Log.Debug("function efl_text_glow2_color_set was called");
6201             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6202             if (ws != null)
6203             {
6204
6205                 try
6206                 {
6207                     ((LayoutPartText)ws.Target).SetGlow2Color(r, g, b, a);
6208                 }
6209                 catch (Exception e)
6210                 {
6211                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6212                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6213                 }
6214
6215
6216             }
6217             else
6218             {
6219                 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);
6220             }
6221         }
6222
6223         private static efl_text_glow2_color_set_delegate efl_text_glow2_color_set_static_delegate;
6224
6225         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
6226         private delegate System.String efl_text_gfx_filter_get_delegate(System.IntPtr obj, System.IntPtr pd);
6227
6228         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
6229         public delegate System.String efl_text_gfx_filter_get_api_delegate(System.IntPtr obj);
6230
6231         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");
6232
6233         private static System.String gfx_filter_get(System.IntPtr obj, System.IntPtr pd)
6234         {
6235             Eina.Log.Debug("function efl_text_gfx_filter_get was called");
6236             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6237             if (ws != null)
6238             {
6239             System.String _ret_var = default(System.String);
6240                 try
6241                 {
6242                     _ret_var = ((LayoutPartText)ws.Target).GetGfxFilter();
6243                 }
6244                 catch (Exception e)
6245                 {
6246                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6247                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6248                 }
6249
6250         return _ret_var;
6251
6252             }
6253             else
6254             {
6255                 return efl_text_gfx_filter_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
6256             }
6257         }
6258
6259         private static efl_text_gfx_filter_get_delegate efl_text_gfx_filter_get_static_delegate;
6260
6261
6262         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);
6263
6264
6265         public delegate void efl_text_gfx_filter_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code);
6266
6267         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");
6268
6269         private static void gfx_filter_set(System.IntPtr obj, System.IntPtr pd, System.String code)
6270         {
6271             Eina.Log.Debug("function efl_text_gfx_filter_set was called");
6272             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
6273             if (ws != null)
6274             {
6275
6276                 try
6277                 {
6278                     ((LayoutPartText)ws.Target).SetGfxFilter(code);
6279                 }
6280                 catch (Exception e)
6281                 {
6282                     Eina.Log.Warning($"Callback error: {e.ToString()}");
6283                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
6284                 }
6285
6286
6287             }
6288             else
6289             {
6290                 efl_text_gfx_filter_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code);
6291             }
6292         }
6293
6294         private static efl_text_gfx_filter_set_delegate efl_text_gfx_filter_set_static_delegate;
6295
6296         #pragma warning restore CA1707, CS1591, SA1300, SA1600
6297
6298 }
6299 }
6300 }
6301
6302 }
6303
6304 namespace Efl {
6305
6306 namespace Canvas {
6307
6308 /// <summary>Text layout policy to enforce. If none is set, min/max descriptions are taken in considerations solely.</summary>
6309 public enum LayoutPartTextExpand
6310 {
6311 /// <summary>No policy. Use default description parameters.</summary>
6312 None = 0,
6313 MinX = 1,
6314 MinY = 2,
6315 MaxX = 4,
6316 MaxY = 8,
6317 }
6318
6319 }
6320
6321 }
6322