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

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