internals/src/EflSharp/EflSharp/efl/efl_text_cursor.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.ComponentModel;
   7 namespace Efl {
   8 /// <summary>Cursor API</summary>
   9 [ITextCursorNativeInherit]
  10 public interface ITextCursor :
  11     Efl.Eo.IWrapper, IDisposable
  12 {
  13     /// <summary>The object&apos;s main cursor.</summary>
  14 /// <param name="get_type">Cursor type</param>
  15 /// <returns>Text cursor object</returns>
  16 Efl.TextCursorCursor GetTextCursor( Efl.TextCursorGetType get_type);
  17     /// <summary>Cursor position</summary>
  18 /// <param name="cur">Cursor object</param>
  19 /// <returns>Cursor position</returns>
  20 int GetCursorPosition( Efl.TextCursorCursor cur);
  21     /// <summary>Cursor position</summary>
  22 /// <param name="cur">Cursor object</param>
  23 /// <param name="position">Cursor position</param>
  24 /// <returns></returns>
  25 void SetCursorPosition( Efl.TextCursorCursor cur,  int position);
  26     /// <summary>The content of the cursor (the character under the cursor)</summary>
  27 /// <param name="cur">Cursor object</param>
  28 /// <returns>The unicode codepoint of the character</returns>
  29 Eina.Unicode GetCursorContent( Efl.TextCursorCursor cur);
  30     /// <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.
  31 /// 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>
  32 /// <param name="cur">Cursor object</param>
  33 /// <param name="ctype">The type of the cursor.</param>
  34 /// <param name="cx">The x of the cursor (or upper cursor)</param>
  35 /// <param name="cy">The y of the cursor (or upper cursor)</param>
  36 /// <param name="cw">The width of the cursor (or upper cursor)</param>
  37 /// <param name="ch">The height of the cursor (or upper cursor)</param>
  38 /// <param name="cx2">The x of the lower cursor</param>
  39 /// <param name="cy2">The y of the lower cursor</param>
  40 /// <param name="cw2">The width of the lower cursor</param>
  41 /// <param name="ch2">The height of the lower cursor</param>
  42 /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
  43 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);
  44     /// <summary>Create new cursor</summary>
  45 /// <returns>Cursor object</returns>
  46 Efl.TextCursorCursor NewCursor();
  47     /// <summary>Free existing cursor</summary>
  48 /// <param name="cur">Cursor object</param>
  49 /// <returns></returns>
  50 void CursorFree( Efl.TextCursorCursor cur);
  51     /// <summary>Check if two cursors are equal</summary>
  52 /// <param name="cur1">Cursor 1 object</param>
  53 /// <param name="cur2">Cursor 2 object</param>
  54 /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
  55 bool CursorEqual( Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
  56     /// <summary>Compare two cursors</summary>
  57 /// <param name="cur1">Cursor 1 object</param>
  58 /// <param name="cur2">Cursor 2 object</param>
  59 /// <returns>Difference between cursors</returns>
  60 int CursorCompare( Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
  61     /// <summary>Copy existing cursor</summary>
  62 /// <param name="dst">Destination cursor</param>
  63 /// <param name="src">Source cursor</param>
  64 /// <returns></returns>
  65 void CursorCopy( Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
  66     /// <summary>Advances to the next character</summary>
  67 /// <param name="cur">Cursor object</param>
  68 /// <returns></returns>
  69 void CursorCharNext( Efl.TextCursorCursor cur);
  70     /// <summary>Advances to the previous character</summary>
  71 /// <param name="cur">Cursor object</param>
  72 /// <returns></returns>
  73 void CursorCharPrev( Efl.TextCursorCursor cur);
  74     /// <summary>Advances to the next grapheme cluster</summary>
  75 /// <param name="cur">Cursor object</param>
  76 /// <returns></returns>
  77 void CursorClusterNext( Efl.TextCursorCursor cur);
  78     /// <summary>Advances to the previous grapheme cluster</summary>
  79 /// <param name="cur">Cursor object</param>
  80 /// <returns></returns>
  81 void CursorClusterPrev( Efl.TextCursorCursor cur);
  82     /// <summary>Advances to the first character in this paragraph</summary>
  83 /// <param name="cur">Cursor object</param>
  84 /// <returns></returns>
  85 void CursorParagraphCharFirst( Efl.TextCursorCursor cur);
  86     /// <summary>Advances to the last character in this paragraph</summary>
  87 /// <param name="cur">Cursor object</param>
  88 /// <returns></returns>
  89 void CursorParagraphCharLast( Efl.TextCursorCursor cur);
  90     /// <summary>Advance to current word start</summary>
  91 /// <param name="cur">Cursor object</param>
  92 /// <returns></returns>
  93 void CursorWordStart( Efl.TextCursorCursor cur);
  94     /// <summary>Advance to current word end</summary>
  95 /// <param name="cur">Cursor object</param>
  96 /// <returns></returns>
  97 void CursorWordEnd( Efl.TextCursorCursor cur);
  98     /// <summary>Advance to current line first character</summary>
  99 /// <param name="cur">Cursor object</param>
 100 /// <returns></returns>
 101 void CursorLineCharFirst( Efl.TextCursorCursor cur);
 102     /// <summary>Advance to current line last character</summary>
 103 /// <param name="cur">Cursor object</param>
 104 /// <returns></returns>
 105 void CursorLineCharLast( Efl.TextCursorCursor cur);
 106     /// <summary>Advance to current paragraph first character</summary>
 107 /// <param name="cur">Cursor object</param>
 108 /// <returns></returns>
 109 void CursorParagraphFirst( Efl.TextCursorCursor cur);
 110     /// <summary>Advance to current paragraph last character</summary>
 111 /// <param name="cur">Cursor object</param>
 112 /// <returns></returns>
 113 void CursorParagraphLast( Efl.TextCursorCursor cur);
 114     /// <summary>Advances to the start of the next text node</summary>
 115 /// <param name="cur">Cursor object</param>
 116 /// <returns></returns>
 117 void CursorParagraphNext( Efl.TextCursorCursor cur);
 118     /// <summary>Advances to the end of the previous text node</summary>
 119 /// <param name="cur">Cursor object</param>
 120 /// <returns></returns>
 121 void CursorParagraphPrev( Efl.TextCursorCursor cur);
 122     /// <summary>Jump the cursor by the given number of lines</summary>
 123 /// <param name="cur">Cursor object</param>
 124 /// <param name="by">Number of lines</param>
 125 /// <returns></returns>
 126 void CursorLineJumpBy( Efl.TextCursorCursor cur,  int by);
 127     /// <summary>Set cursor coordinates</summary>
 128 /// <param name="cur">Cursor object</param>
 129 /// <param name="x">X coord to set by.</param>
 130 /// <param name="y">Y coord to set by.</param>
 131 /// <returns></returns>
 132 void SetCursorCoord( Efl.TextCursorCursor cur,  int x,  int y);
 133     /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
 134 /// <param name="cur">Cursor object</param>
 135 /// <param name="x">X coord to set by.</param>
 136 /// <param name="y">Y coord to set by.</param>
 137 /// <returns></returns>
 138 void SetCursorClusterCoord( Efl.TextCursorCursor cur,  int x,  int y);
 139     /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
 140 /// <param name="cur">Cursor object</param>
 141 /// <param name="text">Text to append (UTF-8 format).</param>
 142 /// <returns>Length of the appended text.</returns>
 143 int CursorTextInsert( Efl.TextCursorCursor cur,  System.String text);
 144     /// <summary>Deletes a single character from position pointed by given cursor.</summary>
 145 /// <param name="cur">Cursor object</param>
 146 /// <returns></returns>
 147 void CursorCharDelete( Efl.TextCursorCursor cur);
 148                                                                                                                     }
 149 /// <summary>Cursor API</summary>
 150 sealed public class ITextCursorConcrete :
 151
 152 ITextCursor
 153
 154 {
 155     ///<summary>Pointer to the native class description.</summary>
 156     public System.IntPtr NativeClass {
 157         get {
 158             if (((object)this).GetType() == typeof (ITextCursorConcrete))
 159                 return Efl.ITextCursorNativeInherit.GetEflClassStatic();
 160             else
 161                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 162         }
 163     }
 164     private  System.IntPtr handle;
 165     ///<summary>Pointer to the native instance.</summary>
 166     public System.IntPtr NativeHandle {
 167         get { return handle; }
 168     }
 169     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 170         efl_text_cursor_interface_get();
 171     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 172     private ITextCursorConcrete(System.IntPtr raw)
 173     {
 174         handle = raw;
 175         RegisterEventProxies();
 176     }
 177     ///<summary>Destructor.</summary>
 178     ~ITextCursorConcrete()
 179     {
 180         Dispose(false);
 181     }
 182     ///<summary>Releases the underlying native instance.</summary>
 183     void Dispose(bool disposing)
 184     {
 185         if (handle != System.IntPtr.Zero) {
 186             Efl.Eo.Globals.efl_unref(handle);
 187             handle = System.IntPtr.Zero;
 188         }
 189     }
 190     ///<summary>Releases the underlying native instance.</summary>
 191     public void Dispose()
 192     {
 193         Dispose(true);
 194         GC.SuppressFinalize(this);
 195     }
 196     ///<summary>Verifies if the given object is equal to this one.</summary>
 197     public override bool Equals(object obj)
 198     {
 199         var other = obj as Efl.Object;
 200         if (other == null)
 201             return false;
 202         return this.NativeHandle == other.NativeHandle;
 203     }
 204     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 205     public override int GetHashCode()
 206     {
 207         return this.NativeHandle.ToInt32();
 208     }
 209     ///<summary>Turns the native pointer into a string representation.</summary>
 210     public override String ToString()
 211     {
 212         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 213     }
 214     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 215      void RegisterEventProxies()
 216     {
 217     }
 218     /// <summary>The object&apos;s main cursor.</summary>
 219     /// <param name="get_type">Cursor type</param>
 220     /// <returns>Text cursor object</returns>
 221     public Efl.TextCursorCursor GetTextCursor( Efl.TextCursorGetType get_type) {
 222                                  var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_get_ptr.Value.Delegate(this.NativeHandle, get_type);
 223         Eina.Error.RaiseIfUnhandledException();
 224                         return _ret_var;
 225  }
 226     /// <summary>Cursor position</summary>
 227     /// <param name="cur">Cursor object</param>
 228     /// <returns>Cursor position</returns>
 229     public int GetCursorPosition( Efl.TextCursorCursor cur) {
 230                                  var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_position_get_ptr.Value.Delegate(this.NativeHandle, cur);
 231         Eina.Error.RaiseIfUnhandledException();
 232                         return _ret_var;
 233  }
 234     /// <summary>Cursor position</summary>
 235     /// <param name="cur">Cursor object</param>
 236     /// <param name="position">Cursor position</param>
 237     /// <returns></returns>
 238     public void SetCursorPosition( Efl.TextCursorCursor cur,  int position) {
 239                                                          Efl.ITextCursorNativeInherit.efl_text_cursor_position_set_ptr.Value.Delegate(this.NativeHandle, cur,  position);
 240         Eina.Error.RaiseIfUnhandledException();
 241                                          }
 242     /// <summary>The content of the cursor (the character under the cursor)</summary>
 243     /// <param name="cur">Cursor object</param>
 244     /// <returns>The unicode codepoint of the character</returns>
 245     public Eina.Unicode GetCursorContent( Efl.TextCursorCursor cur) {
 246                                  var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_content_get_ptr.Value.Delegate(this.NativeHandle, cur);
 247         Eina.Error.RaiseIfUnhandledException();
 248                         return _ret_var;
 249  }
 250     /// <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.
 251     /// 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>
 252     /// <param name="cur">Cursor object</param>
 253     /// <param name="ctype">The type of the cursor.</param>
 254     /// <param name="cx">The x of the cursor (or upper cursor)</param>
 255     /// <param name="cy">The y of the cursor (or upper cursor)</param>
 256     /// <param name="cw">The width of the cursor (or upper cursor)</param>
 257     /// <param name="ch">The height of the cursor (or upper cursor)</param>
 258     /// <param name="cx2">The x of the lower cursor</param>
 259     /// <param name="cy2">The y of the lower cursor</param>
 260     /// <param name="cw2">The width of the lower cursor</param>
 261     /// <param name="ch2">The height of the lower cursor</param>
 262     /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
 263     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) {
 264                                                                                                                                                                                                                                                          var _ret_var = Efl.ITextCursorNativeInherit.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);
 265         Eina.Error.RaiseIfUnhandledException();
 266                                                                                                                                                                         return _ret_var;
 267  }
 268     /// <summary>Create new cursor</summary>
 269     /// <returns>Cursor object</returns>
 270     public Efl.TextCursorCursor NewCursor() {
 271          var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_new_ptr.Value.Delegate(this.NativeHandle);
 272         Eina.Error.RaiseIfUnhandledException();
 273         return _ret_var;
 274  }
 275     /// <summary>Free existing cursor</summary>
 276     /// <param name="cur">Cursor object</param>
 277     /// <returns></returns>
 278     public void CursorFree( Efl.TextCursorCursor cur) {
 279                                  Efl.ITextCursorNativeInherit.efl_text_cursor_free_ptr.Value.Delegate(this.NativeHandle, cur);
 280         Eina.Error.RaiseIfUnhandledException();
 281                          }
 282     /// <summary>Check if two cursors are equal</summary>
 283     /// <param name="cur1">Cursor 1 object</param>
 284     /// <param name="cur2">Cursor 2 object</param>
 285     /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
 286     public bool CursorEqual( Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2) {
 287                                                          var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_equal_ptr.Value.Delegate(this.NativeHandle, cur1,  cur2);
 288         Eina.Error.RaiseIfUnhandledException();
 289                                         return _ret_var;
 290  }
 291     /// <summary>Compare two cursors</summary>
 292     /// <param name="cur1">Cursor 1 object</param>
 293     /// <param name="cur2">Cursor 2 object</param>
 294     /// <returns>Difference between cursors</returns>
 295     public int CursorCompare( Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2) {
 296                                                          var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_compare_ptr.Value.Delegate(this.NativeHandle, cur1,  cur2);
 297         Eina.Error.RaiseIfUnhandledException();
 298                                         return _ret_var;
 299  }
 300     /// <summary>Copy existing cursor</summary>
 301     /// <param name="dst">Destination cursor</param>
 302     /// <param name="src">Source cursor</param>
 303     /// <returns></returns>
 304     public void CursorCopy( Efl.TextCursorCursor dst,  Efl.TextCursorCursor src) {
 305                                                          Efl.ITextCursorNativeInherit.efl_text_cursor_copy_ptr.Value.Delegate(this.NativeHandle, dst,  src);
 306         Eina.Error.RaiseIfUnhandledException();
 307                                          }
 308     /// <summary>Advances to the next character</summary>
 309     /// <param name="cur">Cursor object</param>
 310     /// <returns></returns>
 311     public void CursorCharNext( Efl.TextCursorCursor cur) {
 312                                  Efl.ITextCursorNativeInherit.efl_text_cursor_char_next_ptr.Value.Delegate(this.NativeHandle, cur);
 313         Eina.Error.RaiseIfUnhandledException();
 314                          }
 315     /// <summary>Advances to the previous character</summary>
 316     /// <param name="cur">Cursor object</param>
 317     /// <returns></returns>
 318     public void CursorCharPrev( Efl.TextCursorCursor cur) {
 319                                  Efl.ITextCursorNativeInherit.efl_text_cursor_char_prev_ptr.Value.Delegate(this.NativeHandle, cur);
 320         Eina.Error.RaiseIfUnhandledException();
 321                          }
 322     /// <summary>Advances to the next grapheme cluster</summary>
 323     /// <param name="cur">Cursor object</param>
 324     /// <returns></returns>
 325     public void CursorClusterNext( Efl.TextCursorCursor cur) {
 326                                  Efl.ITextCursorNativeInherit.efl_text_cursor_cluster_next_ptr.Value.Delegate(this.NativeHandle, cur);
 327         Eina.Error.RaiseIfUnhandledException();
 328                          }
 329     /// <summary>Advances to the previous grapheme cluster</summary>
 330     /// <param name="cur">Cursor object</param>
 331     /// <returns></returns>
 332     public void CursorClusterPrev( Efl.TextCursorCursor cur) {
 333                                  Efl.ITextCursorNativeInherit.efl_text_cursor_cluster_prev_ptr.Value.Delegate(this.NativeHandle, cur);
 334         Eina.Error.RaiseIfUnhandledException();
 335                          }
 336     /// <summary>Advances to the first character in this paragraph</summary>
 337     /// <param name="cur">Cursor object</param>
 338     /// <returns></returns>
 339     public void CursorParagraphCharFirst( Efl.TextCursorCursor cur) {
 340                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(this.NativeHandle, cur);
 341         Eina.Error.RaiseIfUnhandledException();
 342                          }
 343     /// <summary>Advances to the last character in this paragraph</summary>
 344     /// <param name="cur">Cursor object</param>
 345     /// <returns></returns>
 346     public void CursorParagraphCharLast( Efl.TextCursorCursor cur) {
 347                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(this.NativeHandle, cur);
 348         Eina.Error.RaiseIfUnhandledException();
 349                          }
 350     /// <summary>Advance to current word start</summary>
 351     /// <param name="cur">Cursor object</param>
 352     /// <returns></returns>
 353     public void CursorWordStart( Efl.TextCursorCursor cur) {
 354                                  Efl.ITextCursorNativeInherit.efl_text_cursor_word_start_ptr.Value.Delegate(this.NativeHandle, cur);
 355         Eina.Error.RaiseIfUnhandledException();
 356                          }
 357     /// <summary>Advance to current word end</summary>
 358     /// <param name="cur">Cursor object</param>
 359     /// <returns></returns>
 360     public void CursorWordEnd( Efl.TextCursorCursor cur) {
 361                                  Efl.ITextCursorNativeInherit.efl_text_cursor_word_end_ptr.Value.Delegate(this.NativeHandle, cur);
 362         Eina.Error.RaiseIfUnhandledException();
 363                          }
 364     /// <summary>Advance to current line first character</summary>
 365     /// <param name="cur">Cursor object</param>
 366     /// <returns></returns>
 367     public void CursorLineCharFirst( Efl.TextCursorCursor cur) {
 368                                  Efl.ITextCursorNativeInherit.efl_text_cursor_line_char_first_ptr.Value.Delegate(this.NativeHandle, cur);
 369         Eina.Error.RaiseIfUnhandledException();
 370                          }
 371     /// <summary>Advance to current line last character</summary>
 372     /// <param name="cur">Cursor object</param>
 373     /// <returns></returns>
 374     public void CursorLineCharLast( Efl.TextCursorCursor cur) {
 375                                  Efl.ITextCursorNativeInherit.efl_text_cursor_line_char_last_ptr.Value.Delegate(this.NativeHandle, cur);
 376         Eina.Error.RaiseIfUnhandledException();
 377                          }
 378     /// <summary>Advance to current paragraph first character</summary>
 379     /// <param name="cur">Cursor object</param>
 380     /// <returns></returns>
 381     public void CursorParagraphFirst( Efl.TextCursorCursor cur) {
 382                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_first_ptr.Value.Delegate(this.NativeHandle, cur);
 383         Eina.Error.RaiseIfUnhandledException();
 384                          }
 385     /// <summary>Advance to current paragraph last character</summary>
 386     /// <param name="cur">Cursor object</param>
 387     /// <returns></returns>
 388     public void CursorParagraphLast( Efl.TextCursorCursor cur) {
 389                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_last_ptr.Value.Delegate(this.NativeHandle, cur);
 390         Eina.Error.RaiseIfUnhandledException();
 391                          }
 392     /// <summary>Advances to the start of the next text node</summary>
 393     /// <param name="cur">Cursor object</param>
 394     /// <returns></returns>
 395     public void CursorParagraphNext( Efl.TextCursorCursor cur) {
 396                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_next_ptr.Value.Delegate(this.NativeHandle, cur);
 397         Eina.Error.RaiseIfUnhandledException();
 398                          }
 399     /// <summary>Advances to the end of the previous text node</summary>
 400     /// <param name="cur">Cursor object</param>
 401     /// <returns></returns>
 402     public void CursorParagraphPrev( Efl.TextCursorCursor cur) {
 403                                  Efl.ITextCursorNativeInherit.efl_text_cursor_paragraph_prev_ptr.Value.Delegate(this.NativeHandle, cur);
 404         Eina.Error.RaiseIfUnhandledException();
 405                          }
 406     /// <summary>Jump the cursor by the given number of lines</summary>
 407     /// <param name="cur">Cursor object</param>
 408     /// <param name="by">Number of lines</param>
 409     /// <returns></returns>
 410     public void CursorLineJumpBy( Efl.TextCursorCursor cur,  int by) {
 411                                                          Efl.ITextCursorNativeInherit.efl_text_cursor_line_jump_by_ptr.Value.Delegate(this.NativeHandle, cur,  by);
 412         Eina.Error.RaiseIfUnhandledException();
 413                                          }
 414     /// <summary>Set cursor coordinates</summary>
 415     /// <param name="cur">Cursor object</param>
 416     /// <param name="x">X coord to set by.</param>
 417     /// <param name="y">Y coord to set by.</param>
 418     /// <returns></returns>
 419     public void SetCursorCoord( Efl.TextCursorCursor cur,  int x,  int y) {
 420                                                                                  Efl.ITextCursorNativeInherit.efl_text_cursor_coord_set_ptr.Value.Delegate(this.NativeHandle, cur,  x,  y);
 421         Eina.Error.RaiseIfUnhandledException();
 422                                                          }
 423     /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
 424     /// <param name="cur">Cursor object</param>
 425     /// <param name="x">X coord to set by.</param>
 426     /// <param name="y">Y coord to set by.</param>
 427     /// <returns></returns>
 428     public void SetCursorClusterCoord( Efl.TextCursorCursor cur,  int x,  int y) {
 429                                                                                  Efl.ITextCursorNativeInherit.efl_text_cursor_cluster_coord_set_ptr.Value.Delegate(this.NativeHandle, cur,  x,  y);
 430         Eina.Error.RaiseIfUnhandledException();
 431                                                          }
 432     /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
 433     /// <param name="cur">Cursor object</param>
 434     /// <param name="text">Text to append (UTF-8 format).</param>
 435     /// <returns>Length of the appended text.</returns>
 436     public int CursorTextInsert( Efl.TextCursorCursor cur,  System.String text) {
 437                                                          var _ret_var = Efl.ITextCursorNativeInherit.efl_text_cursor_text_insert_ptr.Value.Delegate(this.NativeHandle, cur,  text);
 438         Eina.Error.RaiseIfUnhandledException();
 439                                         return _ret_var;
 440  }
 441     /// <summary>Deletes a single character from position pointed by given cursor.</summary>
 442     /// <param name="cur">Cursor object</param>
 443     /// <returns></returns>
 444     public void CursorCharDelete( Efl.TextCursorCursor cur) {
 445                                  Efl.ITextCursorNativeInherit.efl_text_cursor_char_delete_ptr.Value.Delegate(this.NativeHandle, cur);
 446         Eina.Error.RaiseIfUnhandledException();
 447                          }
 448     private static IntPtr GetEflClassStatic()
 449     {
 450         return Efl.ITextCursorConcrete.efl_text_cursor_interface_get();
 451     }
 452 }
 453 public class ITextCursorNativeInherit  : Efl.Eo.NativeClass{
 454     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 455     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 456     {
 457         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 458         var methods = Efl.Eo.Globals.GetUserMethods(type);
 459         if (efl_text_cursor_get_static_delegate == null)
 460             efl_text_cursor_get_static_delegate = new efl_text_cursor_get_delegate(text_cursor_get);
 461         if (methods.FirstOrDefault(m => m.Name == "GetTextCursor") != null)
 462             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)});
 463         if (efl_text_cursor_position_get_static_delegate == null)
 464             efl_text_cursor_position_get_static_delegate = new efl_text_cursor_position_get_delegate(cursor_position_get);
 465         if (methods.FirstOrDefault(m => m.Name == "GetCursorPosition") != null)
 466             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)});
 467         if (efl_text_cursor_position_set_static_delegate == null)
 468             efl_text_cursor_position_set_static_delegate = new efl_text_cursor_position_set_delegate(cursor_position_set);
 469         if (methods.FirstOrDefault(m => m.Name == "SetCursorPosition") != null)
 470             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)});
 471         if (efl_text_cursor_content_get_static_delegate == null)
 472             efl_text_cursor_content_get_static_delegate = new efl_text_cursor_content_get_delegate(cursor_content_get);
 473         if (methods.FirstOrDefault(m => m.Name == "GetCursorContent") != null)
 474             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)});
 475         if (efl_text_cursor_geometry_get_static_delegate == null)
 476             efl_text_cursor_geometry_get_static_delegate = new efl_text_cursor_geometry_get_delegate(cursor_geometry_get);
 477         if (methods.FirstOrDefault(m => m.Name == "GetCursorGeometry") != null)
 478             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)});
 479         if (efl_text_cursor_new_static_delegate == null)
 480             efl_text_cursor_new_static_delegate = new efl_text_cursor_new_delegate(cursor_new);
 481         if (methods.FirstOrDefault(m => m.Name == "NewCursor") != null)
 482             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)});
 483         if (efl_text_cursor_free_static_delegate == null)
 484             efl_text_cursor_free_static_delegate = new efl_text_cursor_free_delegate(cursor_free);
 485         if (methods.FirstOrDefault(m => m.Name == "CursorFree") != null)
 486             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)});
 487         if (efl_text_cursor_equal_static_delegate == null)
 488             efl_text_cursor_equal_static_delegate = new efl_text_cursor_equal_delegate(cursor_equal);
 489         if (methods.FirstOrDefault(m => m.Name == "CursorEqual") != null)
 490             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)});
 491         if (efl_text_cursor_compare_static_delegate == null)
 492             efl_text_cursor_compare_static_delegate = new efl_text_cursor_compare_delegate(cursor_compare);
 493         if (methods.FirstOrDefault(m => m.Name == "CursorCompare") != null)
 494             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)});
 495         if (efl_text_cursor_copy_static_delegate == null)
 496             efl_text_cursor_copy_static_delegate = new efl_text_cursor_copy_delegate(cursor_copy);
 497         if (methods.FirstOrDefault(m => m.Name == "CursorCopy") != null)
 498             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)});
 499         if (efl_text_cursor_char_next_static_delegate == null)
 500             efl_text_cursor_char_next_static_delegate = new efl_text_cursor_char_next_delegate(cursor_char_next);
 501         if (methods.FirstOrDefault(m => m.Name == "CursorCharNext") != null)
 502             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)});
 503         if (efl_text_cursor_char_prev_static_delegate == null)
 504             efl_text_cursor_char_prev_static_delegate = new efl_text_cursor_char_prev_delegate(cursor_char_prev);
 505         if (methods.FirstOrDefault(m => m.Name == "CursorCharPrev") != null)
 506             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)});
 507         if (efl_text_cursor_cluster_next_static_delegate == null)
 508             efl_text_cursor_cluster_next_static_delegate = new efl_text_cursor_cluster_next_delegate(cursor_cluster_next);
 509         if (methods.FirstOrDefault(m => m.Name == "CursorClusterNext") != null)
 510             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)});
 511         if (efl_text_cursor_cluster_prev_static_delegate == null)
 512             efl_text_cursor_cluster_prev_static_delegate = new efl_text_cursor_cluster_prev_delegate(cursor_cluster_prev);
 513         if (methods.FirstOrDefault(m => m.Name == "CursorClusterPrev") != null)
 514             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)});
 515         if (efl_text_cursor_paragraph_char_first_static_delegate == null)
 516             efl_text_cursor_paragraph_char_first_static_delegate = new efl_text_cursor_paragraph_char_first_delegate(cursor_paragraph_char_first);
 517         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharFirst") != null)
 518             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)});
 519         if (efl_text_cursor_paragraph_char_last_static_delegate == null)
 520             efl_text_cursor_paragraph_char_last_static_delegate = new efl_text_cursor_paragraph_char_last_delegate(cursor_paragraph_char_last);
 521         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharLast") != null)
 522             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)});
 523         if (efl_text_cursor_word_start_static_delegate == null)
 524             efl_text_cursor_word_start_static_delegate = new efl_text_cursor_word_start_delegate(cursor_word_start);
 525         if (methods.FirstOrDefault(m => m.Name == "CursorWordStart") != null)
 526             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)});
 527         if (efl_text_cursor_word_end_static_delegate == null)
 528             efl_text_cursor_word_end_static_delegate = new efl_text_cursor_word_end_delegate(cursor_word_end);
 529         if (methods.FirstOrDefault(m => m.Name == "CursorWordEnd") != null)
 530             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)});
 531         if (efl_text_cursor_line_char_first_static_delegate == null)
 532             efl_text_cursor_line_char_first_static_delegate = new efl_text_cursor_line_char_first_delegate(cursor_line_char_first);
 533         if (methods.FirstOrDefault(m => m.Name == "CursorLineCharFirst") != null)
 534             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)});
 535         if (efl_text_cursor_line_char_last_static_delegate == null)
 536             efl_text_cursor_line_char_last_static_delegate = new efl_text_cursor_line_char_last_delegate(cursor_line_char_last);
 537         if (methods.FirstOrDefault(m => m.Name == "CursorLineCharLast") != null)
 538             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)});
 539         if (efl_text_cursor_paragraph_first_static_delegate == null)
 540             efl_text_cursor_paragraph_first_static_delegate = new efl_text_cursor_paragraph_first_delegate(cursor_paragraph_first);
 541         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphFirst") != null)
 542             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)});
 543         if (efl_text_cursor_paragraph_last_static_delegate == null)
 544             efl_text_cursor_paragraph_last_static_delegate = new efl_text_cursor_paragraph_last_delegate(cursor_paragraph_last);
 545         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphLast") != null)
 546             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)});
 547         if (efl_text_cursor_paragraph_next_static_delegate == null)
 548             efl_text_cursor_paragraph_next_static_delegate = new efl_text_cursor_paragraph_next_delegate(cursor_paragraph_next);
 549         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphNext") != null)
 550             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)});
 551         if (efl_text_cursor_paragraph_prev_static_delegate == null)
 552             efl_text_cursor_paragraph_prev_static_delegate = new efl_text_cursor_paragraph_prev_delegate(cursor_paragraph_prev);
 553         if (methods.FirstOrDefault(m => m.Name == "CursorParagraphPrev") != null)
 554             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)});
 555         if (efl_text_cursor_line_jump_by_static_delegate == null)
 556             efl_text_cursor_line_jump_by_static_delegate = new efl_text_cursor_line_jump_by_delegate(cursor_line_jump_by);
 557         if (methods.FirstOrDefault(m => m.Name == "CursorLineJumpBy") != null)
 558             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)});
 559         if (efl_text_cursor_coord_set_static_delegate == null)
 560             efl_text_cursor_coord_set_static_delegate = new efl_text_cursor_coord_set_delegate(cursor_coord_set);
 561         if (methods.FirstOrDefault(m => m.Name == "SetCursorCoord") != null)
 562             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)});
 563         if (efl_text_cursor_cluster_coord_set_static_delegate == null)
 564             efl_text_cursor_cluster_coord_set_static_delegate = new efl_text_cursor_cluster_coord_set_delegate(cursor_cluster_coord_set);
 565         if (methods.FirstOrDefault(m => m.Name == "SetCursorClusterCoord") != null)
 566             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)});
 567         if (efl_text_cursor_text_insert_static_delegate == null)
 568             efl_text_cursor_text_insert_static_delegate = new efl_text_cursor_text_insert_delegate(cursor_text_insert);
 569         if (methods.FirstOrDefault(m => m.Name == "CursorTextInsert") != null)
 570             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)});
 571         if (efl_text_cursor_char_delete_static_delegate == null)
 572             efl_text_cursor_char_delete_static_delegate = new efl_text_cursor_char_delete_delegate(cursor_char_delete);
 573         if (methods.FirstOrDefault(m => m.Name == "CursorCharDelete") != null)
 574             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)});
 575         return descs;
 576     }
 577     public override IntPtr GetEflClass()
 578     {
 579         return Efl.ITextCursorConcrete.efl_text_cursor_interface_get();
 580     }
 581     public static  IntPtr GetEflClassStatic()
 582     {
 583         return Efl.ITextCursorConcrete.efl_text_cursor_interface_get();
 584     }
 585
 586
 587      private delegate Efl.TextCursorCursor efl_text_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorGetType get_type);
 588
 589
 590      public delegate Efl.TextCursorCursor efl_text_cursor_get_api_delegate(System.IntPtr obj,   Efl.TextCursorGetType get_type);
 591      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");
 592      private static Efl.TextCursorCursor text_cursor_get(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorGetType get_type)
 593     {
 594         Eina.Log.Debug("function efl_text_cursor_get was called");
 595         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 596         if(wrapper != null) {
 597                                                 Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
 598             try {
 599                 _ret_var = ((ITextCursor)wrapper).GetTextCursor( get_type);
 600             } catch (Exception e) {
 601                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 602                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 603             }
 604                         return _ret_var;
 605         } else {
 606             return efl_text_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  get_type);
 607         }
 608     }
 609     private static efl_text_cursor_get_delegate efl_text_cursor_get_static_delegate;
 610
 611
 612      private delegate int efl_text_cursor_position_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 613
 614
 615      public delegate int efl_text_cursor_position_get_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 616      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");
 617      private static int cursor_position_get(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 618     {
 619         Eina.Log.Debug("function efl_text_cursor_position_get was called");
 620         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 621         if(wrapper != null) {
 622                                                 int _ret_var = default(int);
 623             try {
 624                 _ret_var = ((ITextCursor)wrapper).GetCursorPosition( cur);
 625             } catch (Exception e) {
 626                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 627                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 628             }
 629                         return _ret_var;
 630         } else {
 631             return efl_text_cursor_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 632         }
 633     }
 634     private static efl_text_cursor_position_get_delegate efl_text_cursor_position_get_static_delegate;
 635
 636
 637      private delegate void efl_text_cursor_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur,   int position);
 638
 639
 640      public delegate void efl_text_cursor_position_set_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur,   int position);
 641      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");
 642      private static void cursor_position_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int position)
 643     {
 644         Eina.Log.Debug("function efl_text_cursor_position_set was called");
 645         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 646         if(wrapper != null) {
 647
 648             try {
 649                 ((ITextCursor)wrapper).SetCursorPosition( cur,  position);
 650             } catch (Exception e) {
 651                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 652                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 653             }
 654                                                 } else {
 655             efl_text_cursor_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur,  position);
 656         }
 657     }
 658     private static efl_text_cursor_position_set_delegate efl_text_cursor_position_set_static_delegate;
 659
 660
 661      private delegate Eina.Unicode efl_text_cursor_content_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 662
 663
 664      public delegate Eina.Unicode efl_text_cursor_content_get_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 665      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");
 666      private static Eina.Unicode cursor_content_get(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 667     {
 668         Eina.Log.Debug("function efl_text_cursor_content_get was called");
 669         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 670         if(wrapper != null) {
 671                                                 Eina.Unicode _ret_var = default(Eina.Unicode);
 672             try {
 673                 _ret_var = ((ITextCursor)wrapper).GetCursorContent( cur);
 674             } catch (Exception e) {
 675                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 676                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 677             }
 678                         return _ret_var;
 679         } else {
 680             return efl_text_cursor_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 681         }
 682     }
 683     private static efl_text_cursor_content_get_delegate efl_text_cursor_content_get_static_delegate;
 684
 685
 686      [return: MarshalAs(UnmanagedType.U1)] 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);
 687
 688
 689      [return: MarshalAs(UnmanagedType.U1)] 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);
 690      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");
 691      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)
 692     {
 693         Eina.Log.Debug("function efl_text_cursor_geometry_get was called");
 694         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 695         if(wrapper != null) {
 696                                                                                                                     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);
 697             try {
 698                 _ret_var = ((ITextCursor)wrapper).GetCursorGeometry( cur,  ctype,  out cx,  out cy,  out cw,  out ch,  out cx2,  out cy2,  out cw2,  out ch2);
 699             } catch (Exception e) {
 700                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 701                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 702             }
 703                                                                                                                                                                         return _ret_var;
 704         } else {
 705             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);
 706         }
 707     }
 708     private static efl_text_cursor_geometry_get_delegate efl_text_cursor_geometry_get_static_delegate;
 709
 710
 711      private delegate Efl.TextCursorCursor efl_text_cursor_new_delegate(System.IntPtr obj, System.IntPtr pd);
 712
 713
 714      public delegate Efl.TextCursorCursor efl_text_cursor_new_api_delegate(System.IntPtr obj);
 715      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");
 716      private static Efl.TextCursorCursor cursor_new(System.IntPtr obj, System.IntPtr pd)
 717     {
 718         Eina.Log.Debug("function efl_text_cursor_new was called");
 719         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 720         if(wrapper != null) {
 721                         Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
 722             try {
 723                 _ret_var = ((ITextCursor)wrapper).NewCursor();
 724             } catch (Exception e) {
 725                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 726                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 727             }
 728         return _ret_var;
 729         } else {
 730             return efl_text_cursor_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 731         }
 732     }
 733     private static efl_text_cursor_new_delegate efl_text_cursor_new_static_delegate;
 734
 735
 736      private delegate void efl_text_cursor_free_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 737
 738
 739      public delegate void efl_text_cursor_free_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 740      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");
 741      private static void cursor_free(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 742     {
 743         Eina.Log.Debug("function efl_text_cursor_free was called");
 744         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 745         if(wrapper != null) {
 746
 747             try {
 748                 ((ITextCursor)wrapper).CursorFree( cur);
 749             } catch (Exception e) {
 750                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 751                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 752             }
 753                                 } else {
 754             efl_text_cursor_free_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 755         }
 756     }
 757     private static efl_text_cursor_free_delegate efl_text_cursor_free_static_delegate;
 758
 759
 760      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_text_cursor_equal_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur1,   Efl.TextCursorCursor cur2);
 761
 762
 763      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_text_cursor_equal_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur1,   Efl.TextCursorCursor cur2);
 764      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");
 765      private static bool cursor_equal(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2)
 766     {
 767         Eina.Log.Debug("function efl_text_cursor_equal was called");
 768         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 769         if(wrapper != null) {
 770                                                                         bool _ret_var = default(bool);
 771             try {
 772                 _ret_var = ((ITextCursor)wrapper).CursorEqual( cur1,  cur2);
 773             } catch (Exception e) {
 774                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 775                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 776             }
 777                                         return _ret_var;
 778         } else {
 779             return efl_text_cursor_equal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur1,  cur2);
 780         }
 781     }
 782     private static efl_text_cursor_equal_delegate efl_text_cursor_equal_static_delegate;
 783
 784
 785      private delegate int efl_text_cursor_compare_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur1,   Efl.TextCursorCursor cur2);
 786
 787
 788      public delegate int efl_text_cursor_compare_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur1,   Efl.TextCursorCursor cur2);
 789      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");
 790      private static int cursor_compare(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2)
 791     {
 792         Eina.Log.Debug("function efl_text_cursor_compare was called");
 793         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 794         if(wrapper != null) {
 795                                                                         int _ret_var = default(int);
 796             try {
 797                 _ret_var = ((ITextCursor)wrapper).CursorCompare( cur1,  cur2);
 798             } catch (Exception e) {
 799                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 800                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 801             }
 802                                         return _ret_var;
 803         } else {
 804             return efl_text_cursor_compare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur1,  cur2);
 805         }
 806     }
 807     private static efl_text_cursor_compare_delegate efl_text_cursor_compare_static_delegate;
 808
 809
 810      private delegate void efl_text_cursor_copy_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor dst,   Efl.TextCursorCursor src);
 811
 812
 813      public delegate void efl_text_cursor_copy_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor dst,   Efl.TextCursorCursor src);
 814      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");
 815      private static void cursor_copy(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src)
 816     {
 817         Eina.Log.Debug("function efl_text_cursor_copy was called");
 818         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 819         if(wrapper != null) {
 820
 821             try {
 822                 ((ITextCursor)wrapper).CursorCopy( dst,  src);
 823             } catch (Exception e) {
 824                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 825                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 826             }
 827                                                 } else {
 828             efl_text_cursor_copy_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dst,  src);
 829         }
 830     }
 831     private static efl_text_cursor_copy_delegate efl_text_cursor_copy_static_delegate;
 832
 833
 834      private delegate void efl_text_cursor_char_next_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 835
 836
 837      public delegate void efl_text_cursor_char_next_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 838      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");
 839      private static void cursor_char_next(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 840     {
 841         Eina.Log.Debug("function efl_text_cursor_char_next was called");
 842         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 843         if(wrapper != null) {
 844
 845             try {
 846                 ((ITextCursor)wrapper).CursorCharNext( cur);
 847             } catch (Exception e) {
 848                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 849                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 850             }
 851                                 } else {
 852             efl_text_cursor_char_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 853         }
 854     }
 855     private static efl_text_cursor_char_next_delegate efl_text_cursor_char_next_static_delegate;
 856
 857
 858      private delegate void efl_text_cursor_char_prev_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 859
 860
 861      public delegate void efl_text_cursor_char_prev_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 862      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");
 863      private static void cursor_char_prev(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 864     {
 865         Eina.Log.Debug("function efl_text_cursor_char_prev was called");
 866         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 867         if(wrapper != null) {
 868
 869             try {
 870                 ((ITextCursor)wrapper).CursorCharPrev( cur);
 871             } catch (Exception e) {
 872                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 873                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 874             }
 875                                 } else {
 876             efl_text_cursor_char_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 877         }
 878     }
 879     private static efl_text_cursor_char_prev_delegate efl_text_cursor_char_prev_static_delegate;
 880
 881
 882      private delegate void efl_text_cursor_cluster_next_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 883
 884
 885      public delegate void efl_text_cursor_cluster_next_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 886      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");
 887      private static void cursor_cluster_next(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 888     {
 889         Eina.Log.Debug("function efl_text_cursor_cluster_next was called");
 890         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 891         if(wrapper != null) {
 892
 893             try {
 894                 ((ITextCursor)wrapper).CursorClusterNext( cur);
 895             } catch (Exception e) {
 896                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 897                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 898             }
 899                                 } else {
 900             efl_text_cursor_cluster_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 901         }
 902     }
 903     private static efl_text_cursor_cluster_next_delegate efl_text_cursor_cluster_next_static_delegate;
 904
 905
 906      private delegate void efl_text_cursor_cluster_prev_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 907
 908
 909      public delegate void efl_text_cursor_cluster_prev_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 910      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");
 911      private static void cursor_cluster_prev(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 912     {
 913         Eina.Log.Debug("function efl_text_cursor_cluster_prev was called");
 914         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 915         if(wrapper != null) {
 916
 917             try {
 918                 ((ITextCursor)wrapper).CursorClusterPrev( cur);
 919             } catch (Exception e) {
 920                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 921                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 922             }
 923                                 } else {
 924             efl_text_cursor_cluster_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 925         }
 926     }
 927     private static efl_text_cursor_cluster_prev_delegate efl_text_cursor_cluster_prev_static_delegate;
 928
 929
 930      private delegate void efl_text_cursor_paragraph_char_first_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 931
 932
 933      public delegate void efl_text_cursor_paragraph_char_first_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 934      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");
 935      private static void cursor_paragraph_char_first(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 936     {
 937         Eina.Log.Debug("function efl_text_cursor_paragraph_char_first was called");
 938         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 939         if(wrapper != null) {
 940
 941             try {
 942                 ((ITextCursor)wrapper).CursorParagraphCharFirst( cur);
 943             } catch (Exception e) {
 944                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 945                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 946             }
 947                                 } else {
 948             efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 949         }
 950     }
 951     private static efl_text_cursor_paragraph_char_first_delegate efl_text_cursor_paragraph_char_first_static_delegate;
 952
 953
 954      private delegate void efl_text_cursor_paragraph_char_last_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 955
 956
 957      public delegate void efl_text_cursor_paragraph_char_last_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 958      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");
 959      private static void cursor_paragraph_char_last(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 960     {
 961         Eina.Log.Debug("function efl_text_cursor_paragraph_char_last was called");
 962         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 963         if(wrapper != null) {
 964
 965             try {
 966                 ((ITextCursor)wrapper).CursorParagraphCharLast( cur);
 967             } catch (Exception e) {
 968                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 969                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 970             }
 971                                 } else {
 972             efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 973         }
 974     }
 975     private static efl_text_cursor_paragraph_char_last_delegate efl_text_cursor_paragraph_char_last_static_delegate;
 976
 977
 978      private delegate void efl_text_cursor_word_start_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
 979
 980
 981      public delegate void efl_text_cursor_word_start_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
 982      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");
 983      private static void cursor_word_start(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
 984     {
 985         Eina.Log.Debug("function efl_text_cursor_word_start was called");
 986         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 987         if(wrapper != null) {
 988
 989             try {
 990                 ((ITextCursor)wrapper).CursorWordStart( cur);
 991             } catch (Exception e) {
 992                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 993                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 994             }
 995                                 } else {
 996             efl_text_cursor_word_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
 997         }
 998     }
 999     private static efl_text_cursor_word_start_delegate efl_text_cursor_word_start_static_delegate;
1000
1001
1002      private delegate void efl_text_cursor_word_end_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1003
1004
1005      public delegate void efl_text_cursor_word_end_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1006      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");
1007      private static void cursor_word_end(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1008     {
1009         Eina.Log.Debug("function efl_text_cursor_word_end was called");
1010         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1011         if(wrapper != null) {
1012
1013             try {
1014                 ((ITextCursor)wrapper).CursorWordEnd( cur);
1015             } catch (Exception e) {
1016                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1017                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1018             }
1019                                 } else {
1020             efl_text_cursor_word_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1021         }
1022     }
1023     private static efl_text_cursor_word_end_delegate efl_text_cursor_word_end_static_delegate;
1024
1025
1026      private delegate void efl_text_cursor_line_char_first_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1027
1028
1029      public delegate void efl_text_cursor_line_char_first_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1030      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");
1031      private static void cursor_line_char_first(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1032     {
1033         Eina.Log.Debug("function efl_text_cursor_line_char_first was called");
1034         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1035         if(wrapper != null) {
1036
1037             try {
1038                 ((ITextCursor)wrapper).CursorLineCharFirst( cur);
1039             } catch (Exception e) {
1040                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1041                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1042             }
1043                                 } else {
1044             efl_text_cursor_line_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1045         }
1046     }
1047     private static efl_text_cursor_line_char_first_delegate efl_text_cursor_line_char_first_static_delegate;
1048
1049
1050      private delegate void efl_text_cursor_line_char_last_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1051
1052
1053      public delegate void efl_text_cursor_line_char_last_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1054      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");
1055      private static void cursor_line_char_last(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1056     {
1057         Eina.Log.Debug("function efl_text_cursor_line_char_last was called");
1058         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1059         if(wrapper != null) {
1060
1061             try {
1062                 ((ITextCursor)wrapper).CursorLineCharLast( cur);
1063             } catch (Exception e) {
1064                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1065                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1066             }
1067                                 } else {
1068             efl_text_cursor_line_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1069         }
1070     }
1071     private static efl_text_cursor_line_char_last_delegate efl_text_cursor_line_char_last_static_delegate;
1072
1073
1074      private delegate void efl_text_cursor_paragraph_first_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1075
1076
1077      public delegate void efl_text_cursor_paragraph_first_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1078      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");
1079      private static void cursor_paragraph_first(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1080     {
1081         Eina.Log.Debug("function efl_text_cursor_paragraph_first was called");
1082         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1083         if(wrapper != null) {
1084
1085             try {
1086                 ((ITextCursor)wrapper).CursorParagraphFirst( cur);
1087             } catch (Exception e) {
1088                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1089                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1090             }
1091                                 } else {
1092             efl_text_cursor_paragraph_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1093         }
1094     }
1095     private static efl_text_cursor_paragraph_first_delegate efl_text_cursor_paragraph_first_static_delegate;
1096
1097
1098      private delegate void efl_text_cursor_paragraph_last_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1099
1100
1101      public delegate void efl_text_cursor_paragraph_last_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1102      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");
1103      private static void cursor_paragraph_last(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1104     {
1105         Eina.Log.Debug("function efl_text_cursor_paragraph_last was called");
1106         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1107         if(wrapper != null) {
1108
1109             try {
1110                 ((ITextCursor)wrapper).CursorParagraphLast( cur);
1111             } catch (Exception e) {
1112                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1113                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1114             }
1115                                 } else {
1116             efl_text_cursor_paragraph_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1117         }
1118     }
1119     private static efl_text_cursor_paragraph_last_delegate efl_text_cursor_paragraph_last_static_delegate;
1120
1121
1122      private delegate void efl_text_cursor_paragraph_next_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1123
1124
1125      public delegate void efl_text_cursor_paragraph_next_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1126      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");
1127      private static void cursor_paragraph_next(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1128     {
1129         Eina.Log.Debug("function efl_text_cursor_paragraph_next was called");
1130         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1131         if(wrapper != null) {
1132
1133             try {
1134                 ((ITextCursor)wrapper).CursorParagraphNext( cur);
1135             } catch (Exception e) {
1136                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1137                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1138             }
1139                                 } else {
1140             efl_text_cursor_paragraph_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1141         }
1142     }
1143     private static efl_text_cursor_paragraph_next_delegate efl_text_cursor_paragraph_next_static_delegate;
1144
1145
1146      private delegate void efl_text_cursor_paragraph_prev_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1147
1148
1149      public delegate void efl_text_cursor_paragraph_prev_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1150      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");
1151      private static void cursor_paragraph_prev(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1152     {
1153         Eina.Log.Debug("function efl_text_cursor_paragraph_prev was called");
1154         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1155         if(wrapper != null) {
1156
1157             try {
1158                 ((ITextCursor)wrapper).CursorParagraphPrev( cur);
1159             } catch (Exception e) {
1160                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1161                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1162             }
1163                                 } else {
1164             efl_text_cursor_paragraph_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1165         }
1166     }
1167     private static efl_text_cursor_paragraph_prev_delegate efl_text_cursor_paragraph_prev_static_delegate;
1168
1169
1170      private delegate void efl_text_cursor_line_jump_by_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur,   int by);
1171
1172
1173      public delegate void efl_text_cursor_line_jump_by_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur,   int by);
1174      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");
1175      private static void cursor_line_jump_by(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int by)
1176     {
1177         Eina.Log.Debug("function efl_text_cursor_line_jump_by was called");
1178         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1179         if(wrapper != null) {
1180
1181             try {
1182                 ((ITextCursor)wrapper).CursorLineJumpBy( cur,  by);
1183             } catch (Exception e) {
1184                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1185                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1186             }
1187                                                 } else {
1188             efl_text_cursor_line_jump_by_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur,  by);
1189         }
1190     }
1191     private static efl_text_cursor_line_jump_by_delegate efl_text_cursor_line_jump_by_static_delegate;
1192
1193
1194      private delegate void efl_text_cursor_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur,   int x,   int y);
1195
1196
1197      public delegate void efl_text_cursor_coord_set_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur,   int x,   int y);
1198      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");
1199      private static void cursor_coord_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y)
1200     {
1201         Eina.Log.Debug("function efl_text_cursor_coord_set was called");
1202         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1203         if(wrapper != null) {
1204
1205             try {
1206                 ((ITextCursor)wrapper).SetCursorCoord( cur,  x,  y);
1207             } catch (Exception e) {
1208                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1209                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1210             }
1211                                                                 } else {
1212             efl_text_cursor_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur,  x,  y);
1213         }
1214     }
1215     private static efl_text_cursor_coord_set_delegate efl_text_cursor_coord_set_static_delegate;
1216
1217
1218      private delegate void efl_text_cursor_cluster_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur,   int x,   int y);
1219
1220
1221      public delegate void efl_text_cursor_cluster_coord_set_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur,   int x,   int y);
1222      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");
1223      private static void cursor_cluster_coord_set(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y)
1224     {
1225         Eina.Log.Debug("function efl_text_cursor_cluster_coord_set was called");
1226         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1227         if(wrapper != null) {
1228
1229             try {
1230                 ((ITextCursor)wrapper).SetCursorClusterCoord( cur,  x,  y);
1231             } catch (Exception e) {
1232                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1233                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1234             }
1235                                                                 } else {
1236             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);
1237         }
1238     }
1239     private static efl_text_cursor_cluster_coord_set_delegate efl_text_cursor_cluster_coord_set_static_delegate;
1240
1241
1242      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);
1243
1244
1245      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);
1246      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");
1247      private static int cursor_text_insert(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  System.String text)
1248     {
1249         Eina.Log.Debug("function efl_text_cursor_text_insert was called");
1250         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1251         if(wrapper != null) {
1252                                                                         int _ret_var = default(int);
1253             try {
1254                 _ret_var = ((ITextCursor)wrapper).CursorTextInsert( cur,  text);
1255             } catch (Exception e) {
1256                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1257                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1258             }
1259                                         return _ret_var;
1260         } else {
1261             return efl_text_cursor_text_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur,  text);
1262         }
1263     }
1264     private static efl_text_cursor_text_insert_delegate efl_text_cursor_text_insert_static_delegate;
1265
1266
1267      private delegate void efl_text_cursor_char_delete_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TextCursorCursor cur);
1268
1269
1270      public delegate void efl_text_cursor_char_delete_api_delegate(System.IntPtr obj,   Efl.TextCursorCursor cur);
1271      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");
1272      private static void cursor_char_delete(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur)
1273     {
1274         Eina.Log.Debug("function efl_text_cursor_char_delete was called");
1275         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1276         if(wrapper != null) {
1277
1278             try {
1279                 ((ITextCursor)wrapper).CursorCharDelete( cur);
1280             } catch (Exception e) {
1281                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1282                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1283             }
1284                                 } else {
1285             efl_text_cursor_char_delete_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cur);
1286         }
1287     }
1288     private static efl_text_cursor_char_delete_delegate efl_text_cursor_char_delete_static_delegate;
1289 }
1290 }
1291 namespace Efl {
1292 /// <summary>All available cursor states</summary>
1293 public enum TextCursorGetType
1294 {
1295 /// <summary>Main cursor state (alias to &quot;main&quot;)</summary>
1296 Default = 0,
1297 /// <summary>Main cursor state</summary>
1298 Main = 1,
1299 /// <summary>Selection begin cursor state</summary>
1300 SelectionBegin = 2,
1301 /// <summary>Selection end cursor state</summary>
1302 SelectionEnd = 3,
1303 /// <summary>Pre-edit start cursor state</summary>
1304 PreeditStart = 4,
1305 /// <summary>Pre-edit end cursor state</summary>
1306 PreeditEnd = 5,
1307 /// <summary>User cursor state</summary>
1308 User = 6,
1309 /// <summary>User extra cursor state</summary>
1310 UserExtra = 7,
1311 }
1312 }
1313 namespace Efl {
1314 /// <summary>Text cursor types</summary>
1315 public enum TextCursorType
1316 {
1317 /// <summary>Cursor type before</summary>
1318 Before = 0,
1319 /// <summary>Cursor type under</summary>
1320 Under = 1,
1321 }
1322 }