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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 /// <summary>Markup data that populates the text object&apos;s style and format</summary>
  11 [Efl.ITextMarkupInteractiveConcrete.NativeMethods]
  12 [Efl.Eo.BindingEntity]
  13 public interface ITextMarkupInteractive :
  14     Efl.ITextCursor ,
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Markup of a given range in the text</summary>
  18 /// <param name="start">Start of the markup region</param>
  19 /// <param name="end">End of markup region</param>
  20 /// <returns>The markup-text representation set to this text of a given range</returns>
  21 System.String GetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end);
  22     /// <summary>Markup of a given range in the text</summary>
  23 /// <param name="start">Start of the markup region</param>
  24 /// <param name="end">End of markup region</param>
  25 /// <param name="markup">The markup-text representation set to this text of a given range</param>
  26 void SetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup);
  27     /// <summary>Inserts a markup text to the text object in a given cursor position</summary>
  28 /// <param name="cur">Cursor position to insert markup</param>
  29 /// <param name="markup">The markup text to insert</param>
  30 void CursorMarkupInsert(Efl.TextCursorCursor cur, System.String markup);
  31             }
  32 /// <summary>Markup data that populates the text object&apos;s style and format</summary>
  33 sealed public class ITextMarkupInteractiveConcrete :
  34     Efl.Eo.EoWrapper
  35     , ITextMarkupInteractive
  36     , Efl.ITextCursor
  37 {
  38     ///<summary>Pointer to the native class description.</summary>
  39     public override System.IntPtr NativeClass
  40     {
  41         get
  42         {
  43             if (((object)this).GetType() == typeof(ITextMarkupInteractiveConcrete))
  44             {
  45                 return GetEflClassStatic();
  46             }
  47             else
  48             {
  49                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  50             }
  51         }
  52     }
  53
  54     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  55     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  56     private ITextMarkupInteractiveConcrete(ConstructingHandle ch) : base(ch)
  57     {
  58     }
  59
  60     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  61         efl_text_markup_interactive_interface_get();
  62     /// <summary>Initializes a new instance of the <see cref="ITextMarkupInteractive"/> class.
  63     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  64     /// <param name="wh">The native pointer to be wrapped.</param>
  65     private ITextMarkupInteractiveConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  66     {
  67     }
  68
  69     /// <summary>Markup of a given range in the text</summary>
  70     /// <param name="start">Start of the markup region</param>
  71     /// <param name="end">End of markup region</param>
  72     /// <returns>The markup-text representation set to this text of a given range</returns>
  73     public System.String GetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end) {
  74                                                          var _ret_var = Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate(this.NativeHandle,start, end);
  75         Eina.Error.RaiseIfUnhandledException();
  76                                         return _ret_var;
  77  }
  78     /// <summary>Markup of a given range in the text</summary>
  79     /// <param name="start">Start of the markup region</param>
  80     /// <param name="end">End of markup region</param>
  81     /// <param name="markup">The markup-text representation set to this text of a given range</param>
  82     public void SetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup) {
  83                                                                                  Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate(this.NativeHandle,start, end, markup);
  84         Eina.Error.RaiseIfUnhandledException();
  85                                                          }
  86     /// <summary>Inserts a markup text to the text object in a given cursor position</summary>
  87     /// <param name="cur">Cursor position to insert markup</param>
  88     /// <param name="markup">The markup text to insert</param>
  89     public void CursorMarkupInsert(Efl.TextCursorCursor cur, System.String markup) {
  90                                                          Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate(this.NativeHandle,cur, markup);
  91         Eina.Error.RaiseIfUnhandledException();
  92                                          }
  93     /// <summary>The object&apos;s main cursor.</summary>
  94     /// <param name="get_type">Cursor type</param>
  95     /// <returns>Text cursor object</returns>
  96     public Efl.TextCursorCursor GetTextCursor(Efl.TextCursorGetType get_type) {
  97                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_get_ptr.Value.Delegate(this.NativeHandle,get_type);
  98         Eina.Error.RaiseIfUnhandledException();
  99                         return _ret_var;
 100  }
 101     /// <summary>Cursor position</summary>
 102     /// <param name="cur">Cursor object</param>
 103     /// <returns>Cursor position</returns>
 104     public int GetCursorPosition(Efl.TextCursorCursor cur) {
 105                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_get_ptr.Value.Delegate(this.NativeHandle,cur);
 106         Eina.Error.RaiseIfUnhandledException();
 107                         return _ret_var;
 108  }
 109     /// <summary>Cursor position</summary>
 110     /// <param name="cur">Cursor object</param>
 111     /// <param name="position">Cursor position</param>
 112     public void SetCursorPosition(Efl.TextCursorCursor cur, int position) {
 113                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_set_ptr.Value.Delegate(this.NativeHandle,cur, position);
 114         Eina.Error.RaiseIfUnhandledException();
 115                                          }
 116     /// <summary>The content of the cursor (the character under the cursor)</summary>
 117     /// <param name="cur">Cursor object</param>
 118     /// <returns>The unicode codepoint of the character</returns>
 119     public Eina.Unicode GetCursorContent(Efl.TextCursorCursor cur) {
 120                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_content_get_ptr.Value.Delegate(this.NativeHandle,cur);
 121         Eina.Error.RaiseIfUnhandledException();
 122                         return _ret_var;
 123  }
 124     /// <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.
 125     /// 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>
 126     /// <param name="cur">Cursor object</param>
 127     /// <param name="ctype">The type of the cursor.</param>
 128     /// <param name="cx">The x of the cursor (or upper cursor)</param>
 129     /// <param name="cy">The y of the cursor (or upper cursor)</param>
 130     /// <param name="cw">The width of the cursor (or upper cursor)</param>
 131     /// <param name="ch">The height of the cursor (or upper cursor)</param>
 132     /// <param name="cx2">The x of the lower cursor</param>
 133     /// <param name="cy2">The y of the lower cursor</param>
 134     /// <param name="cw2">The width of the lower cursor</param>
 135     /// <param name="ch2">The height of the lower cursor</param>
 136     /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
 137     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) {
 138                                                                                                                                                                                                                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_geometry_get_ptr.Value.Delegate(this.NativeHandle,cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
 139         Eina.Error.RaiseIfUnhandledException();
 140                                                                                                                                                                         return _ret_var;
 141  }
 142     /// <summary>Create new cursor</summary>
 143     /// <returns>Cursor object</returns>
 144     public Efl.TextCursorCursor NewCursor() {
 145          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_new_ptr.Value.Delegate(this.NativeHandle);
 146         Eina.Error.RaiseIfUnhandledException();
 147         return _ret_var;
 148  }
 149     /// <summary>Free existing cursor</summary>
 150     /// <param name="cur">Cursor object</param>
 151     public void CursorFree(Efl.TextCursorCursor cur) {
 152                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_free_ptr.Value.Delegate(this.NativeHandle,cur);
 153         Eina.Error.RaiseIfUnhandledException();
 154                          }
 155     /// <summary>Check if two cursors are equal</summary>
 156     /// <param name="cur1">Cursor 1 object</param>
 157     /// <param name="cur2">Cursor 2 object</param>
 158     /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
 159     public bool CursorEqual(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 160                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_equal_ptr.Value.Delegate(this.NativeHandle,cur1, cur2);
 161         Eina.Error.RaiseIfUnhandledException();
 162                                         return _ret_var;
 163  }
 164     /// <summary>Compare two cursors</summary>
 165     /// <param name="cur1">Cursor 1 object</param>
 166     /// <param name="cur2">Cursor 2 object</param>
 167     /// <returns>Difference between cursors</returns>
 168     public int CursorCompare(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 169                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_compare_ptr.Value.Delegate(this.NativeHandle,cur1, cur2);
 170         Eina.Error.RaiseIfUnhandledException();
 171                                         return _ret_var;
 172  }
 173     /// <summary>Copy existing cursor</summary>
 174     /// <param name="dst">Destination cursor</param>
 175     /// <param name="src">Source cursor</param>
 176     public void CursorCopy(Efl.TextCursorCursor dst, Efl.TextCursorCursor src) {
 177                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_copy_ptr.Value.Delegate(this.NativeHandle,dst, src);
 178         Eina.Error.RaiseIfUnhandledException();
 179                                          }
 180     /// <summary>Advances to the next character</summary>
 181     /// <param name="cur">Cursor object</param>
 182     public void CursorCharNext(Efl.TextCursorCursor cur) {
 183                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_next_ptr.Value.Delegate(this.NativeHandle,cur);
 184         Eina.Error.RaiseIfUnhandledException();
 185                          }
 186     /// <summary>Advances to the previous character</summary>
 187     /// <param name="cur">Cursor object</param>
 188     public void CursorCharPrev(Efl.TextCursorCursor cur) {
 189                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_prev_ptr.Value.Delegate(this.NativeHandle,cur);
 190         Eina.Error.RaiseIfUnhandledException();
 191                          }
 192     /// <summary>Advances to the next grapheme cluster</summary>
 193     /// <param name="cur">Cursor object</param>
 194     public void CursorClusterNext(Efl.TextCursorCursor cur) {
 195                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_next_ptr.Value.Delegate(this.NativeHandle,cur);
 196         Eina.Error.RaiseIfUnhandledException();
 197                          }
 198     /// <summary>Advances to the previous grapheme cluster</summary>
 199     /// <param name="cur">Cursor object</param>
 200     public void CursorClusterPrev(Efl.TextCursorCursor cur) {
 201                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_prev_ptr.Value.Delegate(this.NativeHandle,cur);
 202         Eina.Error.RaiseIfUnhandledException();
 203                          }
 204     /// <summary>Advances to the first character in this paragraph</summary>
 205     /// <param name="cur">Cursor object</param>
 206     public void CursorParagraphCharFirst(Efl.TextCursorCursor cur) {
 207                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(this.NativeHandle,cur);
 208         Eina.Error.RaiseIfUnhandledException();
 209                          }
 210     /// <summary>Advances to the last character in this paragraph</summary>
 211     /// <param name="cur">Cursor object</param>
 212     public void CursorParagraphCharLast(Efl.TextCursorCursor cur) {
 213                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(this.NativeHandle,cur);
 214         Eina.Error.RaiseIfUnhandledException();
 215                          }
 216     /// <summary>Advance to current word start</summary>
 217     /// <param name="cur">Cursor object</param>
 218     public void CursorWordStart(Efl.TextCursorCursor cur) {
 219                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_start_ptr.Value.Delegate(this.NativeHandle,cur);
 220         Eina.Error.RaiseIfUnhandledException();
 221                          }
 222     /// <summary>Advance to current word end</summary>
 223     /// <param name="cur">Cursor object</param>
 224     public void CursorWordEnd(Efl.TextCursorCursor cur) {
 225                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_end_ptr.Value.Delegate(this.NativeHandle,cur);
 226         Eina.Error.RaiseIfUnhandledException();
 227                          }
 228     /// <summary>Advance to current line first character</summary>
 229     /// <param name="cur">Cursor object</param>
 230     public void CursorLineCharFirst(Efl.TextCursorCursor cur) {
 231                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_first_ptr.Value.Delegate(this.NativeHandle,cur);
 232         Eina.Error.RaiseIfUnhandledException();
 233                          }
 234     /// <summary>Advance to current line last character</summary>
 235     /// <param name="cur">Cursor object</param>
 236     public void CursorLineCharLast(Efl.TextCursorCursor cur) {
 237                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_last_ptr.Value.Delegate(this.NativeHandle,cur);
 238         Eina.Error.RaiseIfUnhandledException();
 239                          }
 240     /// <summary>Advance to current paragraph first character</summary>
 241     /// <param name="cur">Cursor object</param>
 242     public void CursorParagraphFirst(Efl.TextCursorCursor cur) {
 243                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_first_ptr.Value.Delegate(this.NativeHandle,cur);
 244         Eina.Error.RaiseIfUnhandledException();
 245                          }
 246     /// <summary>Advance to current paragraph last character</summary>
 247     /// <param name="cur">Cursor object</param>
 248     public void CursorParagraphLast(Efl.TextCursorCursor cur) {
 249                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_last_ptr.Value.Delegate(this.NativeHandle,cur);
 250         Eina.Error.RaiseIfUnhandledException();
 251                          }
 252     /// <summary>Advances to the start of the next text node</summary>
 253     /// <param name="cur">Cursor object</param>
 254     public void CursorParagraphNext(Efl.TextCursorCursor cur) {
 255                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_next_ptr.Value.Delegate(this.NativeHandle,cur);
 256         Eina.Error.RaiseIfUnhandledException();
 257                          }
 258     /// <summary>Advances to the end of the previous text node</summary>
 259     /// <param name="cur">Cursor object</param>
 260     public void CursorParagraphPrev(Efl.TextCursorCursor cur) {
 261                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_prev_ptr.Value.Delegate(this.NativeHandle,cur);
 262         Eina.Error.RaiseIfUnhandledException();
 263                          }
 264     /// <summary>Jump the cursor by the given number of lines</summary>
 265     /// <param name="cur">Cursor object</param>
 266     /// <param name="by">Number of lines</param>
 267     public void CursorLineJumpBy(Efl.TextCursorCursor cur, int by) {
 268                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_jump_by_ptr.Value.Delegate(this.NativeHandle,cur, by);
 269         Eina.Error.RaiseIfUnhandledException();
 270                                          }
 271     /// <summary>Set cursor coordinates</summary>
 272     /// <param name="cur">Cursor object</param>
 273     /// <param name="x">X coord to set by.</param>
 274     /// <param name="y">Y coord to set by.</param>
 275     public void SetCursorCoord(Efl.TextCursorCursor cur, int x, int y) {
 276                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_coord_set_ptr.Value.Delegate(this.NativeHandle,cur, x, y);
 277         Eina.Error.RaiseIfUnhandledException();
 278                                                          }
 279     /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
 280     /// <param name="cur">Cursor object</param>
 281     /// <param name="x">X coord to set by.</param>
 282     /// <param name="y">Y coord to set by.</param>
 283     public void SetCursorClusterCoord(Efl.TextCursorCursor cur, int x, int y) {
 284                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_coord_set_ptr.Value.Delegate(this.NativeHandle,cur, x, y);
 285         Eina.Error.RaiseIfUnhandledException();
 286                                                          }
 287     /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
 288     /// <param name="cur">Cursor object</param>
 289     /// <param name="text">Text to append (UTF-8 format).</param>
 290     /// <returns>Length of the appended text.</returns>
 291     public int CursorTextInsert(Efl.TextCursorCursor cur, System.String text) {
 292                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_text_insert_ptr.Value.Delegate(this.NativeHandle,cur, text);
 293         Eina.Error.RaiseIfUnhandledException();
 294                                         return _ret_var;
 295  }
 296     /// <summary>Deletes a single character from position pointed by given cursor.</summary>
 297     /// <param name="cur">Cursor object</param>
 298     public void CursorCharDelete(Efl.TextCursorCursor cur) {
 299                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_delete_ptr.Value.Delegate(this.NativeHandle,cur);
 300         Eina.Error.RaiseIfUnhandledException();
 301                          }
 302     private static IntPtr GetEflClassStatic()
 303     {
 304         return Efl.ITextMarkupInteractiveConcrete.efl_text_markup_interactive_interface_get();
 305     }
 306     /// <summary>Wrapper for native methods and virtual method delegates.
 307     /// For internal use by generated code only.</summary>
 308     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 309     {
 310         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 311         /// <summary>Gets the list of Eo operations to override.</summary>
 312         /// <returns>The list of Eo operations to be overload.</returns>
 313         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 314         {
 315             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 316             var methods = Efl.Eo.Globals.GetUserMethods(type);
 317
 318             if (efl_text_markup_interactive_markup_range_get_static_delegate == null)
 319             {
 320                 efl_text_markup_interactive_markup_range_get_static_delegate = new efl_text_markup_interactive_markup_range_get_delegate(markup_range_get);
 321             }
 322
 323             if (methods.FirstOrDefault(m => m.Name == "GetMarkupRange") != null)
 324             {
 325                 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) });
 326             }
 327
 328             if (efl_text_markup_interactive_markup_range_set_static_delegate == null)
 329             {
 330                 efl_text_markup_interactive_markup_range_set_static_delegate = new efl_text_markup_interactive_markup_range_set_delegate(markup_range_set);
 331             }
 332
 333             if (methods.FirstOrDefault(m => m.Name == "SetMarkupRange") != null)
 334             {
 335                 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) });
 336             }
 337
 338             if (efl_text_markup_interactive_cursor_markup_insert_static_delegate == null)
 339             {
 340                 efl_text_markup_interactive_cursor_markup_insert_static_delegate = new efl_text_markup_interactive_cursor_markup_insert_delegate(cursor_markup_insert);
 341             }
 342
 343             if (methods.FirstOrDefault(m => m.Name == "CursorMarkupInsert") != null)
 344             {
 345                 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) });
 346             }
 347
 348             if (efl_text_cursor_get_static_delegate == null)
 349             {
 350                 efl_text_cursor_get_static_delegate = new efl_text_cursor_get_delegate(text_cursor_get);
 351             }
 352
 353             if (methods.FirstOrDefault(m => m.Name == "GetTextCursor") != null)
 354             {
 355                 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) });
 356             }
 357
 358             if (efl_text_cursor_position_get_static_delegate == null)
 359             {
 360                 efl_text_cursor_position_get_static_delegate = new efl_text_cursor_position_get_delegate(cursor_position_get);
 361             }
 362
 363             if (methods.FirstOrDefault(m => m.Name == "GetCursorPosition") != null)
 364             {
 365                 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) });
 366             }
 367
 368             if (efl_text_cursor_position_set_static_delegate == null)
 369             {
 370                 efl_text_cursor_position_set_static_delegate = new efl_text_cursor_position_set_delegate(cursor_position_set);
 371             }
 372
 373             if (methods.FirstOrDefault(m => m.Name == "SetCursorPosition") != null)
 374             {
 375                 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) });
 376             }
 377
 378             if (efl_text_cursor_content_get_static_delegate == null)
 379             {
 380                 efl_text_cursor_content_get_static_delegate = new efl_text_cursor_content_get_delegate(cursor_content_get);
 381             }
 382
 383             if (methods.FirstOrDefault(m => m.Name == "GetCursorContent") != null)
 384             {
 385                 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) });
 386             }
 387
 388             if (efl_text_cursor_geometry_get_static_delegate == null)
 389             {
 390                 efl_text_cursor_geometry_get_static_delegate = new efl_text_cursor_geometry_get_delegate(cursor_geometry_get);
 391             }
 392
 393             if (methods.FirstOrDefault(m => m.Name == "GetCursorGeometry") != null)
 394             {
 395                 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) });
 396             }
 397
 398             if (efl_text_cursor_new_static_delegate == null)
 399             {
 400                 efl_text_cursor_new_static_delegate = new efl_text_cursor_new_delegate(cursor_new);
 401             }
 402
 403             if (methods.FirstOrDefault(m => m.Name == "NewCursor") != null)
 404             {
 405                 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) });
 406             }
 407
 408             if (efl_text_cursor_free_static_delegate == null)
 409             {
 410                 efl_text_cursor_free_static_delegate = new efl_text_cursor_free_delegate(cursor_free);
 411             }
 412
 413             if (methods.FirstOrDefault(m => m.Name == "CursorFree") != null)
 414             {
 415                 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) });
 416             }
 417
 418             if (efl_text_cursor_equal_static_delegate == null)
 419             {
 420                 efl_text_cursor_equal_static_delegate = new efl_text_cursor_equal_delegate(cursor_equal);
 421             }
 422
 423             if (methods.FirstOrDefault(m => m.Name == "CursorEqual") != null)
 424             {
 425                 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) });
 426             }
 427
 428             if (efl_text_cursor_compare_static_delegate == null)
 429             {
 430                 efl_text_cursor_compare_static_delegate = new efl_text_cursor_compare_delegate(cursor_compare);
 431             }
 432
 433             if (methods.FirstOrDefault(m => m.Name == "CursorCompare") != null)
 434             {
 435                 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) });
 436             }
 437
 438             if (efl_text_cursor_copy_static_delegate == null)
 439             {
 440                 efl_text_cursor_copy_static_delegate = new efl_text_cursor_copy_delegate(cursor_copy);
 441             }
 442
 443             if (methods.FirstOrDefault(m => m.Name == "CursorCopy") != null)
 444             {
 445                 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) });
 446             }
 447
 448             if (efl_text_cursor_char_next_static_delegate == null)
 449             {
 450                 efl_text_cursor_char_next_static_delegate = new efl_text_cursor_char_next_delegate(cursor_char_next);
 451             }
 452
 453             if (methods.FirstOrDefault(m => m.Name == "CursorCharNext") != null)
 454             {
 455                 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) });
 456             }
 457
 458             if (efl_text_cursor_char_prev_static_delegate == null)
 459             {
 460                 efl_text_cursor_char_prev_static_delegate = new efl_text_cursor_char_prev_delegate(cursor_char_prev);
 461             }
 462
 463             if (methods.FirstOrDefault(m => m.Name == "CursorCharPrev") != null)
 464             {
 465                 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) });
 466             }
 467
 468             if (efl_text_cursor_cluster_next_static_delegate == null)
 469             {
 470                 efl_text_cursor_cluster_next_static_delegate = new efl_text_cursor_cluster_next_delegate(cursor_cluster_next);
 471             }
 472
 473             if (methods.FirstOrDefault(m => m.Name == "CursorClusterNext") != null)
 474             {
 475                 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) });
 476             }
 477
 478             if (efl_text_cursor_cluster_prev_static_delegate == null)
 479             {
 480                 efl_text_cursor_cluster_prev_static_delegate = new efl_text_cursor_cluster_prev_delegate(cursor_cluster_prev);
 481             }
 482
 483             if (methods.FirstOrDefault(m => m.Name == "CursorClusterPrev") != null)
 484             {
 485                 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) });
 486             }
 487
 488             if (efl_text_cursor_paragraph_char_first_static_delegate == null)
 489             {
 490                 efl_text_cursor_paragraph_char_first_static_delegate = new efl_text_cursor_paragraph_char_first_delegate(cursor_paragraph_char_first);
 491             }
 492
 493             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharFirst") != null)
 494             {
 495                 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) });
 496             }
 497
 498             if (efl_text_cursor_paragraph_char_last_static_delegate == null)
 499             {
 500                 efl_text_cursor_paragraph_char_last_static_delegate = new efl_text_cursor_paragraph_char_last_delegate(cursor_paragraph_char_last);
 501             }
 502
 503             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharLast") != null)
 504             {
 505                 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) });
 506             }
 507
 508             if (efl_text_cursor_word_start_static_delegate == null)
 509             {
 510                 efl_text_cursor_word_start_static_delegate = new efl_text_cursor_word_start_delegate(cursor_word_start);
 511             }
 512
 513             if (methods.FirstOrDefault(m => m.Name == "CursorWordStart") != null)
 514             {
 515                 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) });
 516             }
 517
 518             if (efl_text_cursor_word_end_static_delegate == null)
 519             {
 520                 efl_text_cursor_word_end_static_delegate = new efl_text_cursor_word_end_delegate(cursor_word_end);
 521             }
 522
 523             if (methods.FirstOrDefault(m => m.Name == "CursorWordEnd") != null)
 524             {
 525                 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) });
 526             }
 527
 528             if (efl_text_cursor_line_char_first_static_delegate == null)
 529             {
 530                 efl_text_cursor_line_char_first_static_delegate = new efl_text_cursor_line_char_first_delegate(cursor_line_char_first);
 531             }
 532
 533             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharFirst") != null)
 534             {
 535                 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) });
 536             }
 537
 538             if (efl_text_cursor_line_char_last_static_delegate == null)
 539             {
 540                 efl_text_cursor_line_char_last_static_delegate = new efl_text_cursor_line_char_last_delegate(cursor_line_char_last);
 541             }
 542
 543             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharLast") != null)
 544             {
 545                 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) });
 546             }
 547
 548             if (efl_text_cursor_paragraph_first_static_delegate == null)
 549             {
 550                 efl_text_cursor_paragraph_first_static_delegate = new efl_text_cursor_paragraph_first_delegate(cursor_paragraph_first);
 551             }
 552
 553             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphFirst") != null)
 554             {
 555                 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) });
 556             }
 557
 558             if (efl_text_cursor_paragraph_last_static_delegate == null)
 559             {
 560                 efl_text_cursor_paragraph_last_static_delegate = new efl_text_cursor_paragraph_last_delegate(cursor_paragraph_last);
 561             }
 562
 563             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphLast") != null)
 564             {
 565                 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) });
 566             }
 567
 568             if (efl_text_cursor_paragraph_next_static_delegate == null)
 569             {
 570                 efl_text_cursor_paragraph_next_static_delegate = new efl_text_cursor_paragraph_next_delegate(cursor_paragraph_next);
 571             }
 572
 573             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphNext") != null)
 574             {
 575                 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) });
 576             }
 577
 578             if (efl_text_cursor_paragraph_prev_static_delegate == null)
 579             {
 580                 efl_text_cursor_paragraph_prev_static_delegate = new efl_text_cursor_paragraph_prev_delegate(cursor_paragraph_prev);
 581             }
 582
 583             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphPrev") != null)
 584             {
 585                 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) });
 586             }
 587
 588             if (efl_text_cursor_line_jump_by_static_delegate == null)
 589             {
 590                 efl_text_cursor_line_jump_by_static_delegate = new efl_text_cursor_line_jump_by_delegate(cursor_line_jump_by);
 591             }
 592
 593             if (methods.FirstOrDefault(m => m.Name == "CursorLineJumpBy") != null)
 594             {
 595                 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) });
 596             }
 597
 598             if (efl_text_cursor_coord_set_static_delegate == null)
 599             {
 600                 efl_text_cursor_coord_set_static_delegate = new efl_text_cursor_coord_set_delegate(cursor_coord_set);
 601             }
 602
 603             if (methods.FirstOrDefault(m => m.Name == "SetCursorCoord") != null)
 604             {
 605                 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) });
 606             }
 607
 608             if (efl_text_cursor_cluster_coord_set_static_delegate == null)
 609             {
 610                 efl_text_cursor_cluster_coord_set_static_delegate = new efl_text_cursor_cluster_coord_set_delegate(cursor_cluster_coord_set);
 611             }
 612
 613             if (methods.FirstOrDefault(m => m.Name == "SetCursorClusterCoord") != null)
 614             {
 615                 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) });
 616             }
 617
 618             if (efl_text_cursor_text_insert_static_delegate == null)
 619             {
 620                 efl_text_cursor_text_insert_static_delegate = new efl_text_cursor_text_insert_delegate(cursor_text_insert);
 621             }
 622
 623             if (methods.FirstOrDefault(m => m.Name == "CursorTextInsert") != null)
 624             {
 625                 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) });
 626             }
 627
 628             if (efl_text_cursor_char_delete_static_delegate == null)
 629             {
 630                 efl_text_cursor_char_delete_static_delegate = new efl_text_cursor_char_delete_delegate(cursor_char_delete);
 631             }
 632
 633             if (methods.FirstOrDefault(m => m.Name == "CursorCharDelete") != null)
 634             {
 635                 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) });
 636             }
 637
 638             return descs;
 639         }
 640         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 641         /// <returns>The native class pointer.</returns>
 642         public override IntPtr GetEflClass()
 643         {
 644             return Efl.ITextMarkupInteractiveConcrete.efl_text_markup_interactive_interface_get();
 645         }
 646
 647         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 648
 649         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
 650         private delegate System.String efl_text_markup_interactive_markup_range_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
 651
 652         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
 653         public delegate System.String efl_text_markup_interactive_markup_range_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
 654
 655         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");
 656
 657         private static System.String markup_range_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end)
 658         {
 659             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_get was called");
 660             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 661             if (ws != null)
 662             {
 663                                                             System.String _ret_var = default(System.String);
 664                 try
 665                 {
 666                     _ret_var = ((ITextMarkupInteractive)ws.Target).GetMarkupRange(start, end);
 667                 }
 668                 catch (Exception e)
 669                 {
 670                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 671                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 672                 }
 673
 674                                         return _ret_var;
 675
 676             }
 677             else
 678             {
 679                 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);
 680             }
 681         }
 682
 683         private static efl_text_markup_interactive_markup_range_get_delegate efl_text_markup_interactive_markup_range_get_static_delegate;
 684
 685
 686         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);
 687
 688
 689         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);
 690
 691         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");
 692
 693         private static void markup_range_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup)
 694         {
 695             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_set was called");
 696             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 697             if (ws != null)
 698             {
 699
 700                 try
 701                 {
 702                     ((ITextMarkupInteractive)ws.Target).SetMarkupRange(start, end, markup);
 703                 }
 704                 catch (Exception e)
 705                 {
 706                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 707                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 708                 }
 709
 710
 711             }
 712             else
 713             {
 714                 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);
 715             }
 716         }
 717
 718         private static efl_text_markup_interactive_markup_range_set_delegate efl_text_markup_interactive_markup_range_set_static_delegate;
 719
 720
 721         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);
 722
 723
 724         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);
 725
 726         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");
 727
 728         private static void cursor_markup_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String markup)
 729         {
 730             Eina.Log.Debug("function efl_text_markup_interactive_cursor_markup_insert was called");
 731             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 732             if (ws != null)
 733             {
 734
 735                 try
 736                 {
 737                     ((ITextMarkupInteractive)ws.Target).CursorMarkupInsert(cur, markup);
 738                 }
 739                 catch (Exception e)
 740                 {
 741                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 742                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 743                 }
 744
 745
 746             }
 747             else
 748             {
 749                 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);
 750             }
 751         }
 752
 753         private static efl_text_markup_interactive_cursor_markup_insert_delegate efl_text_markup_interactive_cursor_markup_insert_static_delegate;
 754
 755
 756         private delegate Efl.TextCursorCursor efl_text_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorGetType get_type);
 757
 758
 759         public delegate Efl.TextCursorCursor efl_text_cursor_get_api_delegate(System.IntPtr obj,  Efl.TextCursorGetType get_type);
 760
 761         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");
 762
 763         private static Efl.TextCursorCursor text_cursor_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorGetType get_type)
 764         {
 765             Eina.Log.Debug("function efl_text_cursor_get was called");
 766             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 767             if (ws != null)
 768             {
 769                                     Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
 770                 try
 771                 {
 772                     _ret_var = ((ITextMarkupInteractive)ws.Target).GetTextCursor(get_type);
 773                 }
 774                 catch (Exception e)
 775                 {
 776                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 777                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 778                 }
 779
 780                         return _ret_var;
 781
 782             }
 783             else
 784             {
 785                 return efl_text_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), get_type);
 786             }
 787         }
 788
 789         private static efl_text_cursor_get_delegate efl_text_cursor_get_static_delegate;
 790
 791
 792         private delegate int efl_text_cursor_position_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
 793
 794
 795         public delegate int efl_text_cursor_position_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
 796
 797         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");
 798
 799         private static int cursor_position_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
 800         {
 801             Eina.Log.Debug("function efl_text_cursor_position_get was called");
 802             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 803             if (ws != null)
 804             {
 805                                     int _ret_var = default(int);
 806                 try
 807                 {
 808                     _ret_var = ((ITextMarkupInteractive)ws.Target).GetCursorPosition(cur);
 809                 }
 810                 catch (Exception e)
 811                 {
 812                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 813                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 814                 }
 815
 816                         return _ret_var;
 817
 818             }
 819             else
 820             {
 821                 return efl_text_cursor_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
 822             }
 823         }
 824
 825         private static efl_text_cursor_position_get_delegate efl_text_cursor_position_get_static_delegate;
 826
 827
 828         private delegate void efl_text_cursor_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int position);
 829
 830
 831         public delegate void efl_text_cursor_position_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int position);
 832
 833         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");
 834
 835         private static void cursor_position_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int position)
 836         {
 837             Eina.Log.Debug("function efl_text_cursor_position_set was called");
 838             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 839             if (ws != null)
 840             {
 841
 842                 try
 843                 {
 844                     ((ITextMarkupInteractive)ws.Target).SetCursorPosition(cur, position);
 845                 }
 846                 catch (Exception e)
 847                 {
 848                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 849                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 850                 }
 851
 852
 853             }
 854             else
 855             {
 856                 efl_text_cursor_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, position);
 857             }
 858         }
 859
 860         private static efl_text_cursor_position_set_delegate efl_text_cursor_position_set_static_delegate;
 861
 862
 863         private delegate Eina.Unicode efl_text_cursor_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
 864
 865
 866         public delegate Eina.Unicode efl_text_cursor_content_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
 867
 868         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");
 869
 870         private static Eina.Unicode cursor_content_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
 871         {
 872             Eina.Log.Debug("function efl_text_cursor_content_get was called");
 873             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 874             if (ws != null)
 875             {
 876                                     Eina.Unicode _ret_var = default(Eina.Unicode);
 877                 try
 878                 {
 879                     _ret_var = ((ITextMarkupInteractive)ws.Target).GetCursorContent(cur);
 880                 }
 881                 catch (Exception e)
 882                 {
 883                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 884                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 885                 }
 886
 887                         return _ret_var;
 888
 889             }
 890             else
 891             {
 892                 return efl_text_cursor_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
 893             }
 894         }
 895
 896         private static efl_text_cursor_content_get_delegate efl_text_cursor_content_get_static_delegate;
 897
 898         [return: MarshalAs(UnmanagedType.U1)]
 899         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);
 900
 901         [return: MarshalAs(UnmanagedType.U1)]
 902         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);
 903
 904         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");
 905
 906         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)
 907         {
 908             Eina.Log.Debug("function efl_text_cursor_geometry_get was called");
 909             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 910             if (ws != null)
 911             {
 912                                                                                                         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);
 913                 try
 914                 {
 915                     _ret_var = ((ITextMarkupInteractive)ws.Target).GetCursorGeometry(cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
 916                 }
 917                 catch (Exception e)
 918                 {
 919                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 920                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 921                 }
 922
 923                                                                                                                                                                         return _ret_var;
 924
 925             }
 926             else
 927             {
 928                 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);
 929             }
 930         }
 931
 932         private static efl_text_cursor_geometry_get_delegate efl_text_cursor_geometry_get_static_delegate;
 933
 934
 935         private delegate Efl.TextCursorCursor efl_text_cursor_new_delegate(System.IntPtr obj, System.IntPtr pd);
 936
 937
 938         public delegate Efl.TextCursorCursor efl_text_cursor_new_api_delegate(System.IntPtr obj);
 939
 940         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");
 941
 942         private static Efl.TextCursorCursor cursor_new(System.IntPtr obj, System.IntPtr pd)
 943         {
 944             Eina.Log.Debug("function efl_text_cursor_new was called");
 945             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 946             if (ws != null)
 947             {
 948             Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
 949                 try
 950                 {
 951                     _ret_var = ((ITextMarkupInteractive)ws.Target).NewCursor();
 952                 }
 953                 catch (Exception e)
 954                 {
 955                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 956                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 957                 }
 958
 959         return _ret_var;
 960
 961             }
 962             else
 963             {
 964                 return efl_text_cursor_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 965             }
 966         }
 967
 968         private static efl_text_cursor_new_delegate efl_text_cursor_new_static_delegate;
 969
 970
 971         private delegate void efl_text_cursor_free_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
 972
 973
 974         public delegate void efl_text_cursor_free_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
 975
 976         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");
 977
 978         private static void cursor_free(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
 979         {
 980             Eina.Log.Debug("function efl_text_cursor_free was called");
 981             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 982             if (ws != null)
 983             {
 984
 985                 try
 986                 {
 987                     ((ITextMarkupInteractive)ws.Target).CursorFree(cur);
 988                 }
 989                 catch (Exception e)
 990                 {
 991                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 992                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 993                 }
 994
 995
 996             }
 997             else
 998             {
 999                 efl_text_cursor_free_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1000             }
1001         }
1002
1003         private static efl_text_cursor_free_delegate efl_text_cursor_free_static_delegate;
1004
1005         [return: MarshalAs(UnmanagedType.U1)]
1006         private delegate bool efl_text_cursor_equal_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
1007
1008         [return: MarshalAs(UnmanagedType.U1)]
1009         public delegate bool efl_text_cursor_equal_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
1010
1011         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");
1012
1013         private static bool cursor_equal(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
1014         {
1015             Eina.Log.Debug("function efl_text_cursor_equal was called");
1016             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1017             if (ws != null)
1018             {
1019                                                             bool _ret_var = default(bool);
1020                 try
1021                 {
1022                     _ret_var = ((ITextMarkupInteractive)ws.Target).CursorEqual(cur1, cur2);
1023                 }
1024                 catch (Exception e)
1025                 {
1026                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1027                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1028                 }
1029
1030                                         return _ret_var;
1031
1032             }
1033             else
1034             {
1035                 return efl_text_cursor_equal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
1036             }
1037         }
1038
1039         private static efl_text_cursor_equal_delegate efl_text_cursor_equal_static_delegate;
1040
1041
1042         private delegate int efl_text_cursor_compare_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
1043
1044
1045         public delegate int efl_text_cursor_compare_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
1046
1047         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");
1048
1049         private static int cursor_compare(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
1050         {
1051             Eina.Log.Debug("function efl_text_cursor_compare was called");
1052             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1053             if (ws != null)
1054             {
1055                                                             int _ret_var = default(int);
1056                 try
1057                 {
1058                     _ret_var = ((ITextMarkupInteractive)ws.Target).CursorCompare(cur1, cur2);
1059                 }
1060                 catch (Exception e)
1061                 {
1062                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1063                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1064                 }
1065
1066                                         return _ret_var;
1067
1068             }
1069             else
1070             {
1071                 return efl_text_cursor_compare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
1072             }
1073         }
1074
1075         private static efl_text_cursor_compare_delegate efl_text_cursor_compare_static_delegate;
1076
1077
1078         private delegate void efl_text_cursor_copy_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
1079
1080
1081         public delegate void efl_text_cursor_copy_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
1082
1083         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");
1084
1085         private static void cursor_copy(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor dst, Efl.TextCursorCursor src)
1086         {
1087             Eina.Log.Debug("function efl_text_cursor_copy was called");
1088             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1089             if (ws != null)
1090             {
1091
1092                 try
1093                 {
1094                     ((ITextMarkupInteractive)ws.Target).CursorCopy(dst, src);
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100                 }
1101
1102
1103             }
1104             else
1105             {
1106                 efl_text_cursor_copy_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dst, src);
1107             }
1108         }
1109
1110         private static efl_text_cursor_copy_delegate efl_text_cursor_copy_static_delegate;
1111
1112
1113         private delegate void efl_text_cursor_char_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1114
1115
1116         public delegate void efl_text_cursor_char_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1117
1118         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");
1119
1120         private static void cursor_char_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1121         {
1122             Eina.Log.Debug("function efl_text_cursor_char_next was called");
1123             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1124             if (ws != null)
1125             {
1126
1127                 try
1128                 {
1129                     ((ITextMarkupInteractive)ws.Target).CursorCharNext(cur);
1130                 }
1131                 catch (Exception e)
1132                 {
1133                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1134                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1135                 }
1136
1137
1138             }
1139             else
1140             {
1141                 efl_text_cursor_char_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1142             }
1143         }
1144
1145         private static efl_text_cursor_char_next_delegate efl_text_cursor_char_next_static_delegate;
1146
1147
1148         private delegate void efl_text_cursor_char_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1149
1150
1151         public delegate void efl_text_cursor_char_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1152
1153         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");
1154
1155         private static void cursor_char_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1156         {
1157             Eina.Log.Debug("function efl_text_cursor_char_prev was called");
1158             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1159             if (ws != null)
1160             {
1161
1162                 try
1163                 {
1164                     ((ITextMarkupInteractive)ws.Target).CursorCharPrev(cur);
1165                 }
1166                 catch (Exception e)
1167                 {
1168                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1169                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1170                 }
1171
1172
1173             }
1174             else
1175             {
1176                 efl_text_cursor_char_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1177             }
1178         }
1179
1180         private static efl_text_cursor_char_prev_delegate efl_text_cursor_char_prev_static_delegate;
1181
1182
1183         private delegate void efl_text_cursor_cluster_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1184
1185
1186         public delegate void efl_text_cursor_cluster_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1187
1188         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");
1189
1190         private static void cursor_cluster_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1191         {
1192             Eina.Log.Debug("function efl_text_cursor_cluster_next was called");
1193             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1194             if (ws != null)
1195             {
1196
1197                 try
1198                 {
1199                     ((ITextMarkupInteractive)ws.Target).CursorClusterNext(cur);
1200                 }
1201                 catch (Exception e)
1202                 {
1203                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1204                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1205                 }
1206
1207
1208             }
1209             else
1210             {
1211                 efl_text_cursor_cluster_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1212             }
1213         }
1214
1215         private static efl_text_cursor_cluster_next_delegate efl_text_cursor_cluster_next_static_delegate;
1216
1217
1218         private delegate void efl_text_cursor_cluster_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1219
1220
1221         public delegate void efl_text_cursor_cluster_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1222
1223         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");
1224
1225         private static void cursor_cluster_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1226         {
1227             Eina.Log.Debug("function efl_text_cursor_cluster_prev was called");
1228             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1229             if (ws != null)
1230             {
1231
1232                 try
1233                 {
1234                     ((ITextMarkupInteractive)ws.Target).CursorClusterPrev(cur);
1235                 }
1236                 catch (Exception e)
1237                 {
1238                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1239                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1240                 }
1241
1242
1243             }
1244             else
1245             {
1246                 efl_text_cursor_cluster_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1247             }
1248         }
1249
1250         private static efl_text_cursor_cluster_prev_delegate efl_text_cursor_cluster_prev_static_delegate;
1251
1252
1253         private delegate void efl_text_cursor_paragraph_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1254
1255
1256         public delegate void efl_text_cursor_paragraph_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1257
1258         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");
1259
1260         private static void cursor_paragraph_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1261         {
1262             Eina.Log.Debug("function efl_text_cursor_paragraph_char_first was called");
1263             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1264             if (ws != null)
1265             {
1266
1267                 try
1268                 {
1269                     ((ITextMarkupInteractive)ws.Target).CursorParagraphCharFirst(cur);
1270                 }
1271                 catch (Exception e)
1272                 {
1273                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1274                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1275                 }
1276
1277
1278             }
1279             else
1280             {
1281                 efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1282             }
1283         }
1284
1285         private static efl_text_cursor_paragraph_char_first_delegate efl_text_cursor_paragraph_char_first_static_delegate;
1286
1287
1288         private delegate void efl_text_cursor_paragraph_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1289
1290
1291         public delegate void efl_text_cursor_paragraph_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1292
1293         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");
1294
1295         private static void cursor_paragraph_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1296         {
1297             Eina.Log.Debug("function efl_text_cursor_paragraph_char_last was called");
1298             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1299             if (ws != null)
1300             {
1301
1302                 try
1303                 {
1304                     ((ITextMarkupInteractive)ws.Target).CursorParagraphCharLast(cur);
1305                 }
1306                 catch (Exception e)
1307                 {
1308                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1309                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1310                 }
1311
1312
1313             }
1314             else
1315             {
1316                 efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1317             }
1318         }
1319
1320         private static efl_text_cursor_paragraph_char_last_delegate efl_text_cursor_paragraph_char_last_static_delegate;
1321
1322
1323         private delegate void efl_text_cursor_word_start_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1324
1325
1326         public delegate void efl_text_cursor_word_start_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1327
1328         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");
1329
1330         private static void cursor_word_start(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1331         {
1332             Eina.Log.Debug("function efl_text_cursor_word_start was called");
1333             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1334             if (ws != null)
1335             {
1336
1337                 try
1338                 {
1339                     ((ITextMarkupInteractive)ws.Target).CursorWordStart(cur);
1340                 }
1341                 catch (Exception e)
1342                 {
1343                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1344                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1345                 }
1346
1347
1348             }
1349             else
1350             {
1351                 efl_text_cursor_word_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1352             }
1353         }
1354
1355         private static efl_text_cursor_word_start_delegate efl_text_cursor_word_start_static_delegate;
1356
1357
1358         private delegate void efl_text_cursor_word_end_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1359
1360
1361         public delegate void efl_text_cursor_word_end_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1362
1363         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");
1364
1365         private static void cursor_word_end(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1366         {
1367             Eina.Log.Debug("function efl_text_cursor_word_end was called");
1368             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1369             if (ws != null)
1370             {
1371
1372                 try
1373                 {
1374                     ((ITextMarkupInteractive)ws.Target).CursorWordEnd(cur);
1375                 }
1376                 catch (Exception e)
1377                 {
1378                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1379                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1380                 }
1381
1382
1383             }
1384             else
1385             {
1386                 efl_text_cursor_word_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1387             }
1388         }
1389
1390         private static efl_text_cursor_word_end_delegate efl_text_cursor_word_end_static_delegate;
1391
1392
1393         private delegate void efl_text_cursor_line_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1394
1395
1396         public delegate void efl_text_cursor_line_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1397
1398         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");
1399
1400         private static void cursor_line_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1401         {
1402             Eina.Log.Debug("function efl_text_cursor_line_char_first was called");
1403             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1404             if (ws != null)
1405             {
1406
1407                 try
1408                 {
1409                     ((ITextMarkupInteractive)ws.Target).CursorLineCharFirst(cur);
1410                 }
1411                 catch (Exception e)
1412                 {
1413                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1414                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1415                 }
1416
1417
1418             }
1419             else
1420             {
1421                 efl_text_cursor_line_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1422             }
1423         }
1424
1425         private static efl_text_cursor_line_char_first_delegate efl_text_cursor_line_char_first_static_delegate;
1426
1427
1428         private delegate void efl_text_cursor_line_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1429
1430
1431         public delegate void efl_text_cursor_line_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1432
1433         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");
1434
1435         private static void cursor_line_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1436         {
1437             Eina.Log.Debug("function efl_text_cursor_line_char_last was called");
1438             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1439             if (ws != null)
1440             {
1441
1442                 try
1443                 {
1444                     ((ITextMarkupInteractive)ws.Target).CursorLineCharLast(cur);
1445                 }
1446                 catch (Exception e)
1447                 {
1448                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1449                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1450                 }
1451
1452
1453             }
1454             else
1455             {
1456                 efl_text_cursor_line_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1457             }
1458         }
1459
1460         private static efl_text_cursor_line_char_last_delegate efl_text_cursor_line_char_last_static_delegate;
1461
1462
1463         private delegate void efl_text_cursor_paragraph_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1464
1465
1466         public delegate void efl_text_cursor_paragraph_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1467
1468         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");
1469
1470         private static void cursor_paragraph_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1471         {
1472             Eina.Log.Debug("function efl_text_cursor_paragraph_first was called");
1473             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1474             if (ws != null)
1475             {
1476
1477                 try
1478                 {
1479                     ((ITextMarkupInteractive)ws.Target).CursorParagraphFirst(cur);
1480                 }
1481                 catch (Exception e)
1482                 {
1483                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1484                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1485                 }
1486
1487
1488             }
1489             else
1490             {
1491                 efl_text_cursor_paragraph_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1492             }
1493         }
1494
1495         private static efl_text_cursor_paragraph_first_delegate efl_text_cursor_paragraph_first_static_delegate;
1496
1497
1498         private delegate void efl_text_cursor_paragraph_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1499
1500
1501         public delegate void efl_text_cursor_paragraph_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1502
1503         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");
1504
1505         private static void cursor_paragraph_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1506         {
1507             Eina.Log.Debug("function efl_text_cursor_paragraph_last was called");
1508             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1509             if (ws != null)
1510             {
1511
1512                 try
1513                 {
1514                     ((ITextMarkupInteractive)ws.Target).CursorParagraphLast(cur);
1515                 }
1516                 catch (Exception e)
1517                 {
1518                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1519                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1520                 }
1521
1522
1523             }
1524             else
1525             {
1526                 efl_text_cursor_paragraph_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1527             }
1528         }
1529
1530         private static efl_text_cursor_paragraph_last_delegate efl_text_cursor_paragraph_last_static_delegate;
1531
1532
1533         private delegate void efl_text_cursor_paragraph_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1534
1535
1536         public delegate void efl_text_cursor_paragraph_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1537
1538         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");
1539
1540         private static void cursor_paragraph_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1541         {
1542             Eina.Log.Debug("function efl_text_cursor_paragraph_next was called");
1543             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1544             if (ws != null)
1545             {
1546
1547                 try
1548                 {
1549                     ((ITextMarkupInteractive)ws.Target).CursorParagraphNext(cur);
1550                 }
1551                 catch (Exception e)
1552                 {
1553                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1554                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1555                 }
1556
1557
1558             }
1559             else
1560             {
1561                 efl_text_cursor_paragraph_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1562             }
1563         }
1564
1565         private static efl_text_cursor_paragraph_next_delegate efl_text_cursor_paragraph_next_static_delegate;
1566
1567
1568         private delegate void efl_text_cursor_paragraph_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1569
1570
1571         public delegate void efl_text_cursor_paragraph_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1572
1573         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");
1574
1575         private static void cursor_paragraph_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1576         {
1577             Eina.Log.Debug("function efl_text_cursor_paragraph_prev was called");
1578             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1579             if (ws != null)
1580             {
1581
1582                 try
1583                 {
1584                     ((ITextMarkupInteractive)ws.Target).CursorParagraphPrev(cur);
1585                 }
1586                 catch (Exception e)
1587                 {
1588                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1589                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1590                 }
1591
1592
1593             }
1594             else
1595             {
1596                 efl_text_cursor_paragraph_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1597             }
1598         }
1599
1600         private static efl_text_cursor_paragraph_prev_delegate efl_text_cursor_paragraph_prev_static_delegate;
1601
1602
1603         private delegate void efl_text_cursor_line_jump_by_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int by);
1604
1605
1606         public delegate void efl_text_cursor_line_jump_by_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int by);
1607
1608         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");
1609
1610         private static void cursor_line_jump_by(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int by)
1611         {
1612             Eina.Log.Debug("function efl_text_cursor_line_jump_by was called");
1613             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1614             if (ws != null)
1615             {
1616
1617                 try
1618                 {
1619                     ((ITextMarkupInteractive)ws.Target).CursorLineJumpBy(cur, by);
1620                 }
1621                 catch (Exception e)
1622                 {
1623                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1624                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1625                 }
1626
1627
1628             }
1629             else
1630             {
1631                 efl_text_cursor_line_jump_by_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, by);
1632             }
1633         }
1634
1635         private static efl_text_cursor_line_jump_by_delegate efl_text_cursor_line_jump_by_static_delegate;
1636
1637
1638         private delegate void efl_text_cursor_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
1639
1640
1641         public delegate void efl_text_cursor_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
1642
1643         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");
1644
1645         private static void cursor_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
1646         {
1647             Eina.Log.Debug("function efl_text_cursor_coord_set was called");
1648             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1649             if (ws != null)
1650             {
1651
1652                 try
1653                 {
1654                     ((ITextMarkupInteractive)ws.Target).SetCursorCoord(cur, x, y);
1655                 }
1656                 catch (Exception e)
1657                 {
1658                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1659                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1660                 }
1661
1662
1663             }
1664             else
1665             {
1666                 efl_text_cursor_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
1667             }
1668         }
1669
1670         private static efl_text_cursor_coord_set_delegate efl_text_cursor_coord_set_static_delegate;
1671
1672
1673         private delegate void efl_text_cursor_cluster_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
1674
1675
1676         public delegate void efl_text_cursor_cluster_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
1677
1678         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");
1679
1680         private static void cursor_cluster_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
1681         {
1682             Eina.Log.Debug("function efl_text_cursor_cluster_coord_set was called");
1683             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1684             if (ws != null)
1685             {
1686
1687                 try
1688                 {
1689                     ((ITextMarkupInteractive)ws.Target).SetCursorClusterCoord(cur, x, y);
1690                 }
1691                 catch (Exception e)
1692                 {
1693                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1694                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1695                 }
1696
1697
1698             }
1699             else
1700             {
1701                 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);
1702             }
1703         }
1704
1705         private static efl_text_cursor_cluster_coord_set_delegate efl_text_cursor_cluster_coord_set_static_delegate;
1706
1707
1708         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);
1709
1710
1711         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);
1712
1713         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");
1714
1715         private static int cursor_text_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String text)
1716         {
1717             Eina.Log.Debug("function efl_text_cursor_text_insert was called");
1718             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1719             if (ws != null)
1720             {
1721                                                             int _ret_var = default(int);
1722                 try
1723                 {
1724                     _ret_var = ((ITextMarkupInteractive)ws.Target).CursorTextInsert(cur, text);
1725                 }
1726                 catch (Exception e)
1727                 {
1728                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1729                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1730                 }
1731
1732                                         return _ret_var;
1733
1734             }
1735             else
1736             {
1737                 return efl_text_cursor_text_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, text);
1738             }
1739         }
1740
1741         private static efl_text_cursor_text_insert_delegate efl_text_cursor_text_insert_static_delegate;
1742
1743
1744         private delegate void efl_text_cursor_char_delete_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
1745
1746
1747         public delegate void efl_text_cursor_char_delete_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
1748
1749         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");
1750
1751         private static void cursor_char_delete(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
1752         {
1753             Eina.Log.Debug("function efl_text_cursor_char_delete was called");
1754             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1755             if (ws != null)
1756             {
1757
1758                 try
1759                 {
1760                     ((ITextMarkupInteractive)ws.Target).CursorCharDelete(cur);
1761                 }
1762                 catch (Exception e)
1763                 {
1764                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1765                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1766                 }
1767
1768
1769             }
1770             else
1771             {
1772                 efl_text_cursor_char_delete_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
1773             }
1774         }
1775
1776         private static efl_text_cursor_char_delete_delegate efl_text_cursor_char_delete_static_delegate;
1777
1778         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1779
1780 }
1781 }
1782 }
1783